You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
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](https://redis.io/docs/latest/operate/kubernetes/re-clusters/redis-flex).
16
+
{{</note>}}
17
+
14
18
## Prerequisites
15
19
16
20
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.
Copy file name to clipboardExpand all lines: content/operate/kubernetes/deployment/helm.md
+4Lines changed: 4 additions & 0 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -149,6 +149,10 @@ The upgrade process automatically updates the operator and its components, inclu
149
149
150
150
After you upgrade the operator, you might need to upgrade your Redis Enterprise clusters, depending on the Redis software version bundled with the operator. For detailed information about the upgrade process, see [Redis Enterprise for Kubernetes upgrade documentation](https://redis.io/docs/latest/operate/kubernetes/upgrade/).
151
151
152
+
{{< note >}}
153
+
If your databases use user-defined modules (custom non-bundled modules), you must take additional steps during the upgrade process. See [Upgrade with user-defined modules]({{< relref "/operate/kubernetes/upgrade/upgrade-redis-cluster#user-defined-modules" >}}) for details.
154
+
{{< /note >}}
155
+
152
156
For more information and options when upgrading charts, see [helm upgrade](https://helm.sh/docs/helm/helm_upgrade/).
Copy file name to clipboardExpand all lines: content/operate/kubernetes/deployment/quick-start.md
+6Lines changed: 6 additions & 0 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -263,6 +263,12 @@ The operator bundle includes a webhook file. The webhook will intercept requests
263
263
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']
264
264
```
265
265
266
+
## Add user-defined modules (optional)
267
+
268
+
If you plan to create databases that use user-defined modules (custom non-bundled modules), you must add them to the REC custom resource before creating the databases.
269
+
270
+
See [User-defined modules]({{< relref "/operate/kubernetes/re-databases/modules#user-defined-modules">}}) for detailed instructions on adding and configuring custom modules.
271
+
266
272
## Create a Redis Enterprise Database (REDB)
267
273
268
274
You can create multiple databases within the same namespace as your REC or in other namespaces.
Copy file name to clipboardExpand all lines: content/operate/kubernetes/re-clusters/cluster-recovery.md
+4Lines changed: 4 additions & 0 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -24,6 +24,10 @@ The Redis Enterprise for Kubernetes automates these recovery steps:
24
24
25
25
{{<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>}}
26
26
27
+
{{< note >}}
28
+
If your cluster uses user-defined modules, the recovery process doesn't block on module validation errors (such as URL or credential issues). The cluster can recover successfully, and you can resolve any module configuration issues after recovery is complete. See [User-defined modules]({{< relref "/operate/kubernetes/re-databases/modules#user-defined-modules" >}}) for more information.
29
+
{{< /note >}}
30
+
27
31
## Prerequisites
28
32
29
33
- For cluster recovery, the cluster must be [deployed with persistence]({{< relref "/operate/kubernetes/recommendations/persistent-volumes" >}}).
Copy file name to clipboardExpand all lines: content/operate/kubernetes/re-clusters/redis-flex.md
+99-31Lines changed: 99 additions & 31 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -10,84 +10,152 @@ linkTitle: Redis Flex
10
10
weight: 16
11
11
---
12
12
13
-
## Prerequisites
13
+
{{<note>}}
14
+
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](https://redis.io/docs/latest/operate/kubernetes/7.22/re-clusters/auto-tiering/).
15
+
{{</note>}}
16
+
17
+
## Overview
18
+
19
+
[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.
14
20
15
-
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.
21
+
Redis Flex provides automatic RAM management and improved performance compared to Auto Tiering.
16
22
17
23
{{<note>}}
18
-
NVMe (non-volatile memory express) SSDs are strongly recommended to achieve the best performance.
24
+
For best performance, use NVMe (non-volatile memory express) SSDs.
19
25
{{</note>}}
20
26
27
+
28
+
## Redis Flex vs Auto Tiering
29
+
21
30
{{<warning>}}
22
31
Redis Flex is not supported for [Active-Active databases]({{< relref "/operate/kubernetes/active-active" >}}).
23
32
{{</warning>}}
24
33
25
34
Before creating your Redis clusters or databases, these SSDs must be:
26
35
27
-
-[locally attached to worker nodes in your Kubernetes cluster](https://kubernetes.io/docs/concepts/storage/volumes/#local)
28
-
- formatted and mounted on the nodes that will run Redis Enterprise pods
29
-
- dedicated to Redis Flex and not shared with other parts of the database, (e.g. durability, binaries)
30
-
-[provisioned as local persistent volumes](https://kubernetes.io/docs/concepts/storage/volumes/#local)
31
-
- 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)
32
-
- a [StorageClass](https://kubernetes.io/docs/concepts/storage/storage-classes/#local) resource with a unique name
33
36
34
-
For more information on node storage, see [Node persistent and ephemeral storage]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}).
37
+
The earlier implementation of Redis Flex is called Auto Tiering, which is available in Redis versions earlier than 8.0.
35
38
36
-
## Create a Redis Enterprise cluster
39
+
The operator automatically selects the appropriate implementation based on your Redis version:
37
40
38
-
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" >}}):
41
+
-**Versions 7.22.2-22 and earlier:** Auto Tiering
42
+
-**Versions 8.0.2-2 and later:** Redis Flex
39
43
40
-
- enable Redis Flex (`enabled: true`)
41
-
- flash storage driver (`bigStoreDriver`)
42
-
-`rocksdb` or `speedb`(default)
43
-
- storage class name (`storageClassName`)
44
-
- minimal flash disk size (`flashDiskSize`)
44
+
Redis Flex differs from Auto Tiering in the following ways:
45
45
46
-
{{<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>}}
46
+
**Redis Flex (8.0.2-2 and later)**
47
47
48
-
{{<warning>}}Switching between storage engines (`speedb` and `rocksdb`) requires guidance by Redis Support or your Account Manager.{{</warning>}}
- Configuration: `rofRamSize` isn't validated with minimum ratio requirements.
51
+
- Redis versions: Redis 8.0 and later
49
52
50
-
{{<warning>}}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. {{</warning>}}
53
+
**Auto Tiering ( 7.22.2-22 and earlier)**
51
54
52
-
Here is an example of an REC custom resource with these attributes:
- Validation: `rofRamSize` must be at least 10% of `memorySize` and can't exceed `memorySize`.
58
+
- Redis versions: Redis versions earlier than 8.0
53
59
54
-
```YAML
60
+
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.
61
+
62
+
## Prerequisites
63
+
64
+
Before you create your Redis clusters or databases, ensure that your SSDs meet the following requirements:
65
+
66
+
-[Locally attached to worker nodes in your Kubernetes cluster](https://kubernetes.io/docs/concepts/storage/volumes/#local)
67
+
- Formatted and mounted on the nodes that run Redis Enterprise pods
68
+
- Dedicated to Redis Flex and not shared with other parts of the database (for example, durability or binaries)
69
+
-[Provisioned as local persistent volumes](https://kubernetes.io/docs/concepts/storage/volumes/#local)
70
+
- 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).
71
+
- Configured with a [StorageClass](https://kubernetes.io/docs/concepts/storage/storage-classes/#local) resource that has a unique name
72
+
73
+
For more information about node storage, see [Node persistent and ephemeral storage]({{< relref "/operate/rs/installing-upgrading/install/plan-deployment/persistent-ephemeral-storage" >}}).
74
+
75
+
## Create a Redis Enterprise cluster
76
+
77
+
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" >}}):
78
+
79
+
-`enabled: true` - Enables Redis Flex
80
+
-`bigStoreDriver: speedb` - Sets the flash storage driver
81
+
-`storageClassName` - Specifies the storage class name
82
+
-`flashDiskSize` - Sets the minimum flash disk size
83
+
84
+
{{<warning>}}
85
+
Redis Flex doesn't support PVC expansion. Do not enable `enablePersistentVolumeResize` in the REC `persistentSpec` if you use `redisOnFlashSpec`. Enabling both will cause conflicts.
86
+
{{</warning>}}
87
+
88
+
The following example shows a Redis Enterprise cluster custom resource with these fields:
89
+
90
+
```yaml
55
91
apiVersion: app.redislabs.com/v1
56
92
kind: RedisEnterpriseCluster
57
93
metadata:
58
94
name: "rec"
95
+
labels:
96
+
app: redis-enterprise
59
97
spec:
60
-
61
98
nodes: 3
62
99
redisOnFlashSpec:
63
100
enabled: true
64
-
bigStoreDriver: speedb
101
+
bigStoreDriver: speedb# Only 'speedb' is suitable for Redis Flex
65
102
storageClassName: local-scsi
66
103
flashDiskSize: 100G
67
104
```
68
105
69
-
### Create a Redis Enterprise database
106
+
{{<note>}}
107
+
108
+
- Set the `enabled` field to `true`.
109
+
- Use `bigStoreDriver: speedb` for Redis Flex support on Redis 8.0 and later.
110
+
- The `flashStorageEngine` field is deprecated. Use `bigStoreDriver` instead.
111
+
112
+
{{</note>}}
70
113
71
-
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:
114
+
## Create a Redis Enterprise database
72
115
73
-
- `isRof: true` enables Redis Flex
74
-
- `rofRamSize`defines the RAM capacity for the database
116
+
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`.
75
117
76
-
Below is an example REDB custom resource:
118
+
Specify the following fields in the REDB custom resource:
119
+
120
+
- `isRof: true` - Enables Redis Flex
121
+
- `redisVersion`- Set to `"8.0"` or later
122
+
- `memorySize`- Defines the total combined memory size (RAM + flash)
123
+
- `rofRamSize`- (Optional) Defines the RAM capacity for the database
124
+
125
+
The following example shows a REDB custom resource:
77
126
78
127
```YAML
79
128
apiVersion: app.redislabs.com/v1alpha1
80
129
kind: RedisEnterpriseDatabase
81
130
metadata:
82
-
name: autoteiring-redb
131
+
name: redis-flex-db
83
132
spec:
84
133
redisEnterpriseCluster:
85
134
name: rec
86
135
isRof: true
136
+
redisVersion: "8.0"
87
137
memorySize: 2GB
88
138
rofRamSize: 0.5GB
89
139
```
90
140
91
141
{{< note >}}
92
-
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`.
142
+
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.
93
143
{{< /note >}}
144
+
145
+
## Upgrade from Auto Tiering to Redis Flex
146
+
147
+
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:
148
+
149
+
1. Stops validating the `rofRamSize` ratio requirement.
150
+
2. Stops reconciling the `bigstore_ram_size` field to avoid configuration drift.
151
+
3. Continues to preserve the database configuration.
152
+
153
+
### Example upgrade scenario
154
+
155
+
The following example shows how to upgrade a database from Auto Tiering to Redis Flex:
156
+
157
+
1. Create a database on Redis 7.2 with `rofRamSize: 200MB`.
158
+
2. Upgrade the database to Redis 8.0 by updating `spec.redisVersion` to `"8.0"`.
159
+
3. Redis Server automatically converts the database to Redis Flex.
160
+
4. The operator detects the conversion and adapts its reconciliation behavior.
161
+
5. Redis now manages the `rofRamSize` field automatically. You can keep the field in the spec for backward compatibility.
![redisdocsapp[bot]](https://avatars.githubusercontent.com/u/1529926?v=4&size=40){kind=avatar}
![github-actions[bot]](https://avatars.githubusercontent.com/in/15368?v=4&size=40){kind=avatar}
0 commit comments