From 5ee59464c7ae9f46d52c7384ef5a27aa89f21cc8 Mon Sep 17 00:00:00 2001 From: Kaitlyn Michael Date: Mon, 24 Nov 2025 13:56:50 -0600 Subject: [PATCH 1/3] redis flex updates --- .../kubernetes/re-clusters/redis-flex.md | 123 +++++++++++++----- 1 file changed, 91 insertions(+), 32 deletions(-) diff --git a/content/operate/kubernetes/re-clusters/redis-flex.md b/content/operate/kubernetes/re-clusters/redis-flex.md index ed22beaa78..6373aa37ec 100644 --- a/content/operate/kubernetes/re-clusters/redis-flex.md +++ b/content/operate/kubernetes/re-clusters/redis-flex.md @@ -7,83 +7,142 @@ categories: - kubernetes description: Deploy a cluster with Redis Flex on Kubernetes. linkTitle: Redis Flex +bannerText: This page applies to Redis Enterprise for Kubernetes version 8.0.2-2 and later. If you use version 7.22.2-22 or earlier, see [Auto Tiering]({{< relref "/operate/kubernetes/7.22/re-clusters/auto-tiering" >}}). weight: 16 --- +## Overview -## Prerequisites +[Redis Flex]({{< relref "/operate/rs/databases/flash" >}}) (previously known as Redis on Flash) extends your node memory to use both RAM and flash storage. Solid state drives (SSDs) store infrequently used (warm) values, while RAM stores your keys and frequently used (hot) values. This approach improves performance and lowers costs for large datasets. -Redis Enterprise Software for Kubernetes supports using Redis Flex (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. +Redis Flex provides automatic RAM management and improved performance compared to Auto Tiering. {{}} -NVMe (non-volatile memory express) SSDs are strongly recommended to achieve the best performance. +For best performance, use NVMe (non-volatile memory express) SSDs. {{}} -Before creating your Redis clusters or databases, these SSDs must be: +## Redis Flex vs Auto Tiering -- [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 Redis Flex 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 +The earlier implementation of Redis Flex is called Auto Tiering, which is available in Redis versions earlier than 8.0. -For more information on node storage, see [Node persistent and ephemeral storage]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}). +The operator automatically selects the appropriate implementation based on your Redis version: -## Create a Redis Enterprise cluster +- **Redis versions earlier than 8.0:** Auto Tiering +- **Redis 8.0 and later:** Redis Flex -To deploy a Redis Enterprise cluster (REC) with Redis Flex, you'll need to specify the following in the `redisOnFlashSpec` section of your [REC custom resource]({{< relref "/operate/kubernetes/reference/api/redis_enterprise_cluster_api" >}}): +Redis Flex differs from Auto Tiering in the following ways: -- enable Redis Flex (`enabled: true`) -- flash storage driver (`bigStoreDriver`) - - `rocksdb` or `speedb`(default) -- storage class name (`storageClassName`) -- minimal flash disk size (`flashDiskSize`) -{{}} 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. {{}} +**Redis Flex (Redis 8.0 and later)** +- Storage engine: Speedb only +- RAM management: Automatic. Redis manages RAM allocation internally. +- Configuration: `rofRamSize` isn't validated with minimum ratio requirements. +- Redis versions: Redis 8.0 and later -{{}}Switching between storage engines (`speedb` and `rocksdb`) requires guidance by Redis Support or your Account Manager.{{}} +**Auto Tiering (Redis versions earlier than 8.0)** +- Storage engine: RocksDB or Speedb +- RAM management: Manual. Requires explicit `rofRamSize` configuration. +- Validation: `rofRamSize` must be at least 10% of `memorySize` and can't exceed `memorySize`. +- Redis versions: Redis versions earlier than 8.0 -{{}}PVC expansion is not supported when using Redis Flex. Do not enable `enablePersistentVolumeResize` in the REC `persistentSpec` if you are using `redisOnFlashSpec` as this will result in conflicts. {{}} +The operator doesn't support Redis 7.4 preview for Redis Flex. Redis 7.4 databases use Auto Tiering regardless of cluster policy. To use Redis Flex, upgrade to Redis 8.0 or later. -Here is an example of an REC custom resource with these attributes: +## Prerequisites -```YAML +Before you create your Redis clusters or databases, ensure that your SSDs meet the following requirements: + +- [Locally attached to worker nodes in your Kubernetes cluster](https://kubernetes.io/docs/concepts/storage/volumes/#local) +- Formatted and mounted on the nodes that run Redis Enterprise pods +- Dedicated to Redis Flex and not shared with other parts of the database (for example, durability or 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 provision volumes [dynamically](https://kubernetes.io/docs/concepts/storage/persistent-volumes/#dynamic). +- Configured with a [StorageClass](https://kubernetes.io/docs/concepts/storage/storage-classes/#local) resource that has a unique name + +For more information about 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 Redis Flex, specify the following fields in the `redisOnFlashSpec` section of your [REC custom resource]({{< relref "/operate/kubernetes/reference/api/redis_enterprise_cluster_api#specredisonflashspec" >}}): + +- `enabled: true` - Enables Redis Flex +- `bigStoreDriver: speedb` - Sets the flash storage driver +- `storageClassName` - Specifies the storage class name +- `flashDiskSize` - Sets the minimum flash disk size + +{{}} +Redis Flex doesn't support PVC expansion. Do not enable `enablePersistentVolumeResize` in the REC `persistentSpec` if you use `redisOnFlashSpec`. Enabling both will cause conflicts. +{{}} + +The following example shows a Redis Enterprise cluster custom resource with these fields: + +```yaml apiVersion: app.redislabs.com/v1 kind: RedisEnterpriseCluster metadata: name: "rec" + labels: + app: redis-enterprise spec: - nodes: 3 redisOnFlashSpec: enabled: true - bigStoreDriver: speedb + bigStoreDriver: speedb # Only 'speedb' is suitable for Redis Flex storageClassName: local-scsi flashDiskSize: 100G ``` -### Create a Redis Enterprise database +{{}} + +- Set the `enabled` field to `true`. +- Use `bigStoreDriver: speedb` for Redis Flex support on Redis 8.0 and later. +- The `flashStorageEngine` field is deprecated. Use `bigStoreDriver` instead. + +{{}} + +## Create a Redis Enterprise database + +By default, new databases use RAM only. To create a Redis Enterprise database (REDB) that uses Redis Flex and takes advantage of locally attached SSDs, set `isRof` to `true`. -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: +Specify the following fields in the REDB custom resource: -- `isRof: true` enables Redis Flex -- `rofRamSize` defines the RAM capacity for the database +- `isRof: true` - Enables Redis Flex +- `redisVersion` - Set to `"8.0"` or later +- `memorySize` - Defines the total combined memory size (RAM + flash) +- `rofRamSize` - (Optional) Defines the RAM capacity for the database -Below is an example REDB custom resource: +The following example shows a REDB custom resource: ```YAML apiVersion: app.redislabs.com/v1alpha1 kind: RedisEnterpriseDatabase metadata: - name: autoteiring-redb + name: redis-flex-db spec: redisEnterpriseCluster: name: rec isRof: true + redisVersion: "8.0" memorySize: 2GB rofRamSize: 0.5GB ``` {{< note >}} -This example defines both `memorySize` and `rofRamSize`. When using Redis Flex, `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`. +Redis Flex automatically manages RAM allocation. You can specify `rofRamSize`, but it isn't subject to the 10% minimum ratio requirement that applies to Auto Tiering. The operator doesn't validate or enforce minimum RAM ratios for Redis 8.0 and later databases. {{< /note >}} + +## Upgrade from Auto Tiering to Redis Flex + +When you upgrade a database from a Redis version earlier than 8.0 to Redis 8.0 or later, Redis Server automatically migrates the database from Auto Tiering to Redis Flex. The operator detects this migration and makes the following changes: + +1. Stops validating the `rofRamSize` ratio requirement. +2. Stops reconciling the `bigstore_ram_size` field to avoid configuration drift. +3. Continues to preserve the database configuration. + +### Example upgrade scenario + +The following example shows how to upgrade a database from Auto Tiering to Redis Flex: + +1. Create a database on Redis 7.2 with `rofRamSize: 200MB`. +2. Upgrade the database to Redis 8.0 by updating `spec.redisVersion` to `"8.0"`. +3. Redis Server automatically converts the database to Redis Flex. +4. The operator detects the conversion and adapts its reconciliation behavior. +5. Redis now manages the `rofRamSize` field automatically. You can keep the field in the spec for backward compatibility. From cb80afe86b8216f43f6c0a550ab0f1ff83b7143f Mon Sep 17 00:00:00 2001 From: Kaitlyn Michael Date: Mon, 24 Nov 2025 14:01:25 -0600 Subject: [PATCH 2/3] edits for clarity and formatting --- .../operate/kubernetes/7.22/re-clusters/auto-tiering.md | 4 ++++ content/operate/kubernetes/re-clusters/redis-flex.md | 9 +++++---- 2 files changed, 9 insertions(+), 4 deletions(-) diff --git a/content/operate/kubernetes/7.22/re-clusters/auto-tiering.md b/content/operate/kubernetes/7.22/re-clusters/auto-tiering.md index aceefadd56..5df7cac860 100644 --- a/content/operate/kubernetes/7.22/re-clusters/auto-tiering.md +++ b/content/operate/kubernetes/7.22/re-clusters/auto-tiering.md @@ -11,6 +11,10 @@ weight: 16 url: '/operate/kubernetes/7.22/re-clusters/auto-tiering/' --- +{{}} +This page applies to Redis Enterprise for Kubernetes version 7.22.2-22. If you use version 8.0.2-2 or later, see [Redis Flex]({{< relref "/operate/kubernetes/re-clusters/redis-flex" >}}). +{{}} + ## 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. diff --git a/content/operate/kubernetes/re-clusters/redis-flex.md b/content/operate/kubernetes/re-clusters/redis-flex.md index 6373aa37ec..35c38f2410 100644 --- a/content/operate/kubernetes/re-clusters/redis-flex.md +++ b/content/operate/kubernetes/re-clusters/redis-flex.md @@ -26,19 +26,20 @@ The earlier implementation of Redis Flex is called Auto Tiering, which is availa The operator automatically selects the appropriate implementation based on your Redis version: -- **Redis versions earlier than 8.0:** Auto Tiering -- **Redis 8.0 and later:** Redis Flex +- **Versions 7.22.2-22 and earlier:** Auto Tiering +- **Versions 8.0.2-2 and later:** Redis Flex Redis Flex differs from Auto Tiering in the following ways: +**Redis Flex (8.0.2-2 and later)** -**Redis Flex (Redis 8.0 and later)** - Storage engine: Speedb only - RAM management: Automatic. Redis manages RAM allocation internally. - Configuration: `rofRamSize` isn't validated with minimum ratio requirements. - Redis versions: Redis 8.0 and later -**Auto Tiering (Redis versions earlier than 8.0)** +**Auto Tiering ( 7.22.2-22 and earlier)** + - Storage engine: RocksDB or Speedb - RAM management: Manual. Requires explicit `rofRamSize` configuration. - Validation: `rofRamSize` must be at least 10% of `memorySize` and can't exceed `memorySize`. From a69945f55a9188b49a81567118cf54df4e2b48fe Mon Sep 17 00:00:00 2001 From: Kaitlyn Michael Date: Mon, 24 Nov 2025 14:05:17 -0600 Subject: [PATCH 3/3] fix build issue --- content/operate/kubernetes/re-clusters/redis-flex.md | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/content/operate/kubernetes/re-clusters/redis-flex.md b/content/operate/kubernetes/re-clusters/redis-flex.md index 35c38f2410..8df2c74652 100644 --- a/content/operate/kubernetes/re-clusters/redis-flex.md +++ b/content/operate/kubernetes/re-clusters/redis-flex.md @@ -7,9 +7,13 @@ categories: - kubernetes description: Deploy a cluster with Redis Flex on Kubernetes. linkTitle: Redis Flex -bannerText: This page applies to Redis Enterprise for Kubernetes version 8.0.2-2 and later. If you use version 7.22.2-22 or earlier, see [Auto Tiering]({{< relref "/operate/kubernetes/7.22/re-clusters/auto-tiering" >}}). weight: 16 --- + +{{}} +This page applies to Redis Enterprise for Kubernetes version 8.0.2-2 and later. If you use version 7.22.2-22 or earlier, see [Auto Tiering]({{< relref "/operate/kubernetes/7.22/re-clusters/auto-tiering" >}}). +{{}} + ## Overview [Redis Flex]({{< relref "/operate/rs/databases/flash" >}}) (previously known as Redis on Flash) extends your node memory to use both RAM and flash storage. Solid state drives (SSDs) store infrequently used (warm) values, while RAM stores your keys and frequently used (hot) values. This approach improves performance and lowers costs for large datasets.