
# 修改DCS实例配置参数
为了确保分布式缓存服务发挥出最优性能，您可以根据自己的业务情况对DCS缓存实例的运行参数进行调整。实例配置参数修改之后，参数会立即生效（不需要手动重启实例），如果是集群实例，会在所有分片生效。
例如，如需关闭实例的持久化功能，需要将"appendonly"修改为"no"。更多缓存实例的参数说明请参考[缓存实例配置参数说明]。
#### 修改实例配置参数
1. 登录[分布式缓存服务管理控制台](https://console.huaweicloud.com/dcs)。
2. 在管理控制台左上角单击![](https://support.huaweicloud.com/usermanual-dcs/zh-cn_image_0000001549115173.png)，选择实例所在的区域。
3. 单击左侧菜单栏的"缓存管理"。
4. 在"缓存管理"页面，单击DCS缓存实例的名称。
5. 单击"实例配置 \> 参数配置"进入配置界面。
6. 单击需要修改的参数右侧的"修改"，修改该参数。如果需要同时修改多个参数，单击参数列表上方的"修改"，可以同时修改多个参数。 
   图1修改参数   
   ![](https://support.huaweicloud.com/usermanual-dcs/zh-cn_image_0000002043373121.png "点击放大")
   
   
7. 根据需要修改配置参数。 
   各参数的详细介绍见[缓存实例配置参数说明]，一般情况下，按照系统默认值设置参数即可。
   
   
8. 单击"保存"。
9. 在弹出的修改确认对话框中，单击"是"，确认修改参数。 
   参数修改的任务状态"成功"后，修改参数成功。
   
   
 
 #### 缓存实例配置参数说明
- [表1]中的内存优化相关参数可以参考Redis官网说明，链接：<https://redis.io/topics/memory-optimization>。
- 不同实例类型和版本支持配置的参数和取值可能略有不同，控制台参数配置页面中未显示的参数不支持修改。
 表1Redis缓存实例配置参数说明 
| 参数名                                                           | 参数解释                                                                                                                                                                                                                                                                                                                                                                                                                      | 例外场景                                                                                                                                                                                                                                                              | 取值范围                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 默认值                                                                                                                                                                       |
|:---|:---|:---|:---|:---|
| active-expire-num                                             | 定期删除过期键时随机检查key的数量。 如果增加该参数值，短时间内可能出现CPU使用率升高，命令时延增大，随后恢复正常。如果减小该参数值，内存中过期key数量可能上升，占用更多的内存。                                                                                                                                                                                                                                                                                              | Redis 3.0和Redis 6.0企业版实例不支持该参数。 说明： 该参数为2021年9月新增，在此之前创建的实例，如果无法正常修改参数值，请[提交工单](https://console.huaweicloud.com/ticket/#/ticketindex/createIndex)联系客服处理。                                          | 1～1,000                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | 20                                                                                                                                                                        |
| timeout                                                       | 客户端空闲N秒（timeout参数的取值）后将断开连接。参数值为0表示禁用该功能，即客户端空闲不会断开连接。                                                                                                                                                                                                                                                                                                                                                                    | -                                                                                                                                                                                                                                                                 | 0\~7200 单位：秒                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | 0                                                                                                                                                                         |
| appendfsync                                                   | 操作系统的fsync函数刷新缓冲区数据到磁盘，有些操作系统会真正刷新磁盘上的数据，其他一些操作系统只会尝试尽快完成。                                                                                                                                                                                                                                                                                                                                                                | 单机实例不支持该参数。                                                                                                                                                                                                                                                       | - no：不调用fsync，由操作系统决定何时刷新数据到磁盘，性能最高。  - always：每次写AOF文件都调用fsync，性能最差，但数据最安全。  - everysec：每秒调用一次fsync。兼具数据安全和性能。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | no                                                                                                                                                                        |
| appendonly                                                    | 指定是否在每次更新操作后进行日志记录，Redis在默认情况下是异步的把数据写入磁盘，如果不开启日志记录（数据持久化），可能会在断电时导致一段时间内的数据丢失。                                                                                                                                                                                                                                                                                                                                           | 单机实例不支持该参数。 仅Redis 4.0及以上版本的基础版主备或集群实例，或企业版高性能型主备实例支持only-replica配置项。 如果以上版本及实例类型的实例，控制台中无only-replica配置项，可以[提交工单](https://console.huaweicloud.com/ticket/#/ticketindex/createIndex)联系客服放通该配置项。 | - yes：开启日志记录，即开启数据持久化功能。  - no：关闭日志记录，即关闭数据持久化功能。  - only-replica：仅开启从节点数据持久化功能。 注意： 当主备/读写分离实例的appendonly参数设置为only-replica时，请不要将全部从节点的主备切换优先级设置为0（[主备切换优先级默认为100，设置为0表示不支持主备切换](https://support.huaweicloud.com/usermanual-dcs/dcs-ug-190718001.html)），否则主节点会自动开启数据持久化。                                                                                                                                                                                                                                                                                                                                                                                                                                     | yes                                                                                                                                                                       |
| client-output-buffer-limit-slave-soft-seconds                 | 主从同步缓冲区大小超过client-output-buffer-slave-soft-limit主从同步缓冲区大小软限制，并持续时间超过此参数值时，服务端会主动断开连接。该参数值配置的越小，越容易断开连接。                                                                                                                                                                                                                                                                                                                   | 单机实例不支持该参数。                                                                                                                                                                                                                                                       | 0\~60 单位：秒                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 60                                                                                                                                                                        |
| client-output-buffer-slave-hard-limit                         | 主从同步缓冲区大小硬限制。如果同步缓冲区大小超过这个值，则主从同步连接立即断开。该参数值配置的越小，越容易断开连接。                                                                                                                                                                                                                                                                                                                                                                | 单机实例不支持该参数。                                                                                                                                                                                                                                                       | 0～17,179,869,184 单位：字节                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | 1,717,986,918                                                                                                                                                             |
| client-output-buffer-slave-soft-limit                         | 主从同步缓冲区大小软限制。如果同步缓冲区大小超过这个值，并持续时间达到client-output-buffer-limit-slave-soft-seconds参数配置的秒数，则主从同步连接断开。该参数值配置的越小，越容易断开连接。                                                                                                                                                                                                                                                                                                      | 单机实例不支持该参数。                                                                                                                                                                                                                                                       | 0～17,179,869,184 单位：字节                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 1,717,986,918                                                                                                                                                             |
| maxmemory-policy                                              | 内存使用达到上限（maxmemory）时，对缓存数据的逐出策略，有8个取值供选择。                                                                                                                                                                                                                                                                                                                                                                                 | -                                                                                                                                                                                                                                                                 | - volatile-lru：根据LRU算法删除设置了过期时间的键值。  - allkeys-lru：根据LRU算法删除任一键值。  - volatile-random：删除设置了过期时间的随机键值。  - allkeys-random：删除一个随机键值。  - volatile-ttl：删除即将过期的键值，即TTL值最小的键值。  - noeviction：不删除任何键值，只是返回一个写错误。  - volatile-lfu: 根据LFU算法删除设置了过期时间的键值。  - allkeys-lfu: 根据LFU算法删除任一键值。   详情可参考Redis官网的[逐出策略](https://docs.redis.com/latest/rs/databases/memory-performance/eviction-policy/)。 | volatile-lru 说明： 如果是2020年7月之前创建的Redis实例，且没有修改过该参数，则默认值为noeviction。如果是2020年7月之后创建的实例，默认值都为volatile-lru。 |
| lua-time-limit                                                | Lua脚本的最长执行时间。                                                                                                                                                                                                                                                                                                                                                                                                             | -                                                                                                                                                                                                                                                                 | 100～5,000 单位：毫秒                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 5,000                                                                                                                                                                     |
| master-read-only                                              | 设置实例为只读状态。设置只读后，所有写入命令将返回失败。                                                                                                                                                                                                                                                                                                                                                                                              | Proxy集群和读写分离实例不支持该参数。                                                                                                                                                                                                                                             | - yes  - no                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | no                                                                                                                                                                        |
| maxclients                                                    | 最大同时连接的客户端个数。客户端数量超过该配置值时，会发生连接失败。该参数值配置过大时，会增加服务器处理连接的开销，影响服务器性能，命令时延增大；该参数值配置过小，可能无法完全发挥服务器的性能。 该参数为单节点（单分片）连接数上限： - 集群实例单节点连接数上限=实例连接数上限/分片数。  - 单机/主备实例，单节点连接数上限=实例最大连接数。   | 读写分离实例暂不支持该参数。                                                                                                                                                                                                                                                    | 1,000～50,000                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 10,000                                                                                                                                                                    |
| proto-max-bulk-len                                            | Redis协议中的最大的请求大小。该参数的配置值需要大于客户请求的长度，否则请求将无法执行。                                                                                                                                                                                                                                                                                                                                                                            | -                                                                                                                                                                                                                                                                 | 1,048,576～536,870,912 单位：字节                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 536,870,912                                                                                                                                                               |
| repl-backlog-size                                             | 用于增量同步的复制积压缓冲区大小。这是一个用来在从节点断开连接时，存放从节点数据的缓冲区，当从节点重新连接时，如果丢失的数据少于缓冲区的大小，可以用缓冲区中的数据开始增量同步。                                                                                                                                                                                                                                                                                                                                  | -                                                                                                                                                                                                                                                                 | 16,384～1,073,741,824 单位：字节                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 1,048,576                                                                                                                                                                 |
| repl-backlog-ttl                                              | 从节点断开后，主节点释放复制积压缓冲区内存的秒数。值为0时表示永不释放复制积压缓冲区内存。                                                                                                                                                                                                                                                                                                                                                                             | -                                                                                                                                                                                                                                                                 | 0～604,800 单位：秒                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 3,600                                                                                                                                                                     |
| repl-timeout                                                  | 主从同步超时时间。                                                                                                                                                                                                                                                                                                                                                                                                                 | 单机实例不支持该参数。                                                                                                                                                                                                                                                       | 30～3,600 单位：秒                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 60                                                                                                                                                                        |
| hash-max-ziplist-entries                                      | 当hash表中记录数少于参数值，使用ziplist编码格式，节约内存。                                                                                                                                                                                                                                                                                                                                                                                       | -                                                                                                                                                                                                                                                                 | 1\~10000                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 512                                                                                                                                                                       |
| hash-max-ziplist-value                                        | 当hash表中各字段长度的最大值小于参数值时，使用ziplist编码格式，节约内存。                                                                                                                                                                                                                                                                                                                                                                                | -                                                                                                                                                                                                                                                                 | 1\~10000                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 64                                                                                                                                                                        |
| set-max-intset-entries                                        | 当一个集合仅包含字符串且整型元素数量少于参数值时，使用intset编码格式，节约内存。                                                                                                                                                                                                                                                                                                                                                                               | -                                                                                                                                                                                                                                                                 | 1\~10000                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 512                                                                                                                                                                       |
| zset-max-ziplist-entries                                      | 当有序集合中记录数少于参数值，使用ziplist编码格式，节约内存。                                                                                                                                                                                                                                                                                                                                                                                        | -                                                                                                                                                                                                                                                                 | 1\~10000                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 128                                                                                                                                                                       |
| zset-max-ziplist-value                                        | 当有序集合中各字段长度的最大值小于参数值时，使用ziplist编码格式，节约内存。                                                                                                                                                                                                                                                                                                                                                                                 | -                                                                                                                                                                                                                                                                 | 1\~10000                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 64                                                                                                                                                                        |
| latency-monitor-threshold                                     | 延时监控的采样时间阈值（最小值）。 当阈值设置为0时，不做监控，也不采样；当阈值设置为大于0时，将监控并记录执行耗时大于阈值的操作。 您可以通过LATENCY等命令获取统计数据和配置、执行采样监控。 注意： latency-monitor-threshold参数一般在定位问题时使用。采集完latency信息，定位问题后，建议重新将latency-monitor-threshold设置为0，以免引起不必要的延迟。                                                                         | Proxy集群和读写分离实例不支持该参数。                                                                                                                                                                                                                                             | 0\~86400000 单位：毫秒                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 0                                                                                                                                                                         |
| notify-keyspace-events                                        | 键空间通知，配置该参数后客户端可以通过Redis的订阅与发布功能，来接收那些以某种方式改动了Redis数据集的事件。该参数配置为空时，功能关闭。当参数不是空字符串时，功能开启。                                                                                                                                                                                                                                                                                                                                  | Proxy集群和读写分离实例不支持该参数。                                                                                                                                                                                                                                             | 可配置为以下字符的任意组合，指定了服务器该发送哪些类型的通知： K：键空间通知，所有通知以__keyspace@__为前缀。 E：键事件通知，所有通知以__keyevent@__为前缀。 g：DEL、EXPIRE、RENAME等类型无关的通用命令的通知。 $：字符串命令的通知。 l：列表命令的通知。 s：集合命令的通知。 h：哈希命令的通知。 z：有序集合命令的通知。 x：过期事件：每当有过期键被删除时发送。 e：驱逐(evict)事件：每当有键因为maxmemory政策而被删除时发送。 A：参数g$lshzxe的别名。 输入的参数中至少有一个K或者E，A不能与g$lshzxe同时出现，不能出现相同字母。例如，如果只想订阅键空间中和列表相关的通知，那么参数就应该设为Kl。将参数设为字符串"AKE"表示发送所有类型的通知。                                                                                                                                                                                                  | Ex                                                                                                                                                                        |
| slowlog-log-slower-than                                       | Redis慢查询会记录超过指定执行时间的命令。slowlog-log-slower-than用于配置记录到redis慢查询命令执行时间阈值。                                                                                                                                                                                                                                                                                                                                                    | -                                                                                                                                                                                                                                                                 | 0～1,000,000 单位：微秒                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 10,000                                                                                                                                                                    |
| proxy-slowlog-log-slower-than                                 | Proxy节点慢查询会记录超过指定执行时间的命令。proxy-slowlog-log-slower-than用于配置记录到proxy节点慢查询命令的执行时间阈值。                                                                                                                                                                                                                                                                                                                                         | 目前仅"华东-上海二"和"华南-广州"区域的Proxy集群和读写分离实例支持该参数。                                                                                                                                                                                                                        | 30,000～2,000,000 单位：微秒                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 256,000                                                                                                                                                                   |
| slowlog-max-len                                               | Redis慢查询记录的条数。注意慢查询记录会消耗额外的内存。可以通过执行SLOWLOG RESET命令清除慢查询记录。                                                                                                                                                                                                                                                                                                                                                               | -                                                                                                                                                                                                                                                                 | 0～1,000                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | 128                                                                                                                                                                       |
| proxy-slowlog-max-len                                         | Proxy节点慢查询记录的条数。注意慢查询记录会消耗额外的内存。可以通过执行SLOWLOG RESET命令清除慢查询记录。                                                                                                                                                                                                                                                                                                                                                             | 目前仅"华东-上海二"和"华南-广州"区域的Proxy集群和读写分离实例支持该参数。                                                                                                                                                                                                                        | 0～1,000                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | 128                                                                                                                                                                       |
| multi-db                                                      | 开启或关闭多DB特性。要求先清除已有数据。清除数据之前请先手动备份生成备份文件。若要恢复已清除的数据请通过数据迁移页面的备份导入功能进行数据恢复。 Proxy集群开启多DB的使用限制请参见[Proxy集群开启多DB的使用限制及操作方式](https://support.huaweicloud.com/dcs_faq/dcs-faq-210804001.html)。                                                                                                                                                                                                  | 仅Redis 4.0及以上版本的Proxy集群实例支持该参数。                                                                                                                                                                                                                                   | - yes：开启  - no：关闭                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | no                                                                                                                                                                        |
| auto-kill-timeout-lua-process                                 | 开启该参数时，执行超时的lua脚本进程会被自动kill。如果lua脚本执行了写操作无法kill，并且实例开启了持久化时，则该lua脚本所在的节点会自动重启，lua脚本执行的写操作将不被保存。                                                                                                                                                                                                                                                                                                                           | 单机实例和Redis 3.0实例不支持该参数。                                                                                                                                                                                                                                           | - yes：开启  - no：关闭                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | no                                                                                                                                                                        |
| audit-log-customer-command-list                               | 审计日志需要额外记录的命令。审计日志默认只记录写命令，该参数可以指定用户额外需要记录的命令。只有在开启了审计日志的情况下才有效。                                                                                                                                                                                                                                                                                                                                                          | [审计日志](https://support.huaweicloud.com/usermanual-dcs/dcs-ug-221101.html)目前仅部分区域支持，只有支持审计日志特性，并且仅当实例类型为Proxy集群实例时，才显示该参数。                                                                                                                                         | 该参数配置的值必须由英文字母或与.-_组成的命令，且必须以英文字母开头和结尾，每个命令最大长度为10，最多支持配置10个命令。命令之间用空格隔开， 配置的内容最后必须以空格结尾。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | -                                                                                                                                                                         |
| backend-master-only                                           | Proxy集群实例默认关闭读写分离。读、写请求默认只分配到Proxy集群的主节点。Proxy集群实例开启读写分离后，写请求分配到主节点，读请求会默认转发给从节点。 当read-only-slave-when-wr-split参数配置为no时，读请求平均分配到Proxy集群的主节点和备节点。                                                                                                                                                                                                                                         | 仅Proxy集群实例支持该参数。 如果配置了其他读请求配置项，读请求可能会根据配置由主节点、备节点、或平均分配到主备节点处理，详情请参考[读请求处理优先级]。                                                                                                             | - yes：关闭读写分离。  - no：开启读写分离。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | yes                                                                                                                                                                       |
| read-only-slave-when-wr-split                                 | Proxy集群和读写分离实例仅在开启读写分离时，该参数生效。（读写分离实例默认已开启读写分离。Proxy集群实例需要手动设置backend-master-only参数为no来开启读写分离） Proxy集群和读写分离实例开启读写分离后，读操作默认仅在从节点执行，支持配置为在主节点和从节点都进行读操作。                                                                                                                                                                                                                                    | 仅Redis 4.0及以上版本Proxy集群和读写分离实例支持该参数，其他实例类型不支持。 如果配置了其他读请求配置项，读请求可能会根据配置由主节点、备节点、或平均分配到主备节点处理，详情请参考[读请求处理优先级]。                                                                                | yes：仅在从节点进行读操作。 no：在主节点和从节点都进行读操作。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | yes                                                                                                                                                                       |
| support-dispatch-to-replica-list                              | 该参数用于将指定的读命令只均匀分配给slave节点。**目前仅支持配置的命令为** **keys** **，其他命令暂不支持。**                                                                                                                                                                                                                                                                                                                                                         | 仅当实例类型为Proxy集群或读写分离实例，且当实例的proxy版本号大于等于5.0.14.12时，支持该参数。                                                                                                                                                                                                          | 该参数默认值为空，当配置为keys时，表示keys命令仅在从节点执行。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | -                                                                                                                                                                         |
| dispatch-pubsub-to-fixed-shard                                | 该参数用于指定发布订阅的channel是否集中在0号槽位对应的分片上。开启开关时，发布订阅的处理逻辑与单机版一致。用户轻度使用发布订阅时，推荐开启开关。用户重度使用发布订阅功能时，请使用默认配置，让订阅分担到全部分片中。                                                                                                                                                                                                                                                                                                            | 仅Proxy集群实例支持该参数。                                                                                                                                                                                                                                                  | - yes：开启开关。订阅的channel都集中在0号槽位对应的集群分片上。  - no：关闭开关。根据订阅channel值计算出hash槽位值，再将channel分散到各个槽位对应的分片中。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | no                                                                                                                                                                        |
| readonly-lua-route-to-slave-enabled                           | 是否把只读账号的只读lua路由到从节点，如果开启，只读账号的只读lua可以执行，且会路由到从节点。                                                                                                                                                                                                                                                                                                                                                                         | 仅读写分离实例支持该参数。                                                                                                                                                                                                                                                     | - yes：开启  - no：关闭                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | no                                                                                                                                                                        |
| cluster-sentinel-enabled                                      | 实例兼容哨兵（Sentinel）模式。                                                                                                                                                                                                                                                                                                                                                                                                       | 仅Proxy集群实例支持该参数。                                                                                                                                                                                                                                                  | - yes：开启  - no：关闭                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | no                                                                                                                                                                        |
| scan-support-wr-split  | 该参数关闭时，scan命令在master节点执行，该参数开启后，scan命令将在slave节点执行。 开启该参数后，可以降低scan命令对主节点的压力，但对于新写入主节点的数据，可能无法第一时间在从节点查询到。                                                                                                                                                                                                                                                                                  | 仅Proxy集群实例支持该参数。 如果历史创建的Proxy集群实例不支持该参数，请[提交工单](https://console.huaweicloud.com/ticket/#/ticketindex/createIndex)联系客服升级实例版本。                                                                                                      | - yes：开启  - no：关闭                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | no                                                                                                                                                                        |
| cluster-mode-enabled                                          | Proxy集群的info cluster返回信息需与开源Redis Cluster保持一致，Proxy集群cluster_enabled的值由该参数控制： 该参数关闭时，cluster_enabled=0。 该参数开启时，cluster_enabled=1。                                                                                                                                                                                                                          | 仅当实例类型为Proxy集群实例，且当实例的Proxy版本号大于等于5.0.14.12时，支持该参数。                                                                                                                                                                                                               | - yes：开启  - no：关闭                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | no                                                                                                                                                                        |
   
表2Memcached缓存实例配置参数说明 
| 参数名                     | 参数解释                                         | 取值范围                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 默认值        |
|:---|:---|:---|:---|
| timeout                 | 客户端与服务端连接空闲超时断开时间，参数设为0表示连接永不断开。             | 0\~7200 单位：秒                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | 0          |
| maxclients              | 最大同时连接的客户端个数。                                | 1,000～10,000                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | 10,000     |
| maxmemory-policy        | 内存使用达到上限时对缓存数据管理策略。                          | - volatile-lru：根据LRU算法删除设置了过期时间的键值。  - allkeys-lru：根据LRU算法删除任一键值。  - volatile-random：删除设置了过期时间的随机键值。  - allkeys-random：删除一个随机键值。  - volatile-ttl：删除即将过期的键值，即TTL值最小的键值。  - noeviction：不删除任何键值，只是返回一个写错误。   | noeviction |
| reserved-memory-percent | 预留给后台进程用于持久化、主从同步等内部处理的内存百分比（相对于最大可用内存的百分比）。 | 0-80                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 30         |
   
 #### 读请求处理优先级
Proxy集群实例和读写分离实例的读请求处理策略，取决于以下参数配置项及ACL子账号只读路由策略配置，各项配置的配置场景说明和依赖关系请参见[表3]，**下表中配置项由上到下优先级依次降低**。
 表3读请求配置项场景及说明 
| 读请求配置项                                                                                                       | 配置场景                                                                                                                                                          | 配置场景说明（关于处理读请求节点的说明）                                                                                                                                                                                                                                                                                                                             |
|:---|:---|:---|
| 是否开启读写分离 backend-master-only                                                | Proxy集群实例默认关闭读写分离（backend-master-only为yes）。                                                                                                                   | **Proxy集群实例关闭读写分离时，仅在主节点处理读请求，且其他读请求配置项无法开启/配置。**                                                                                                                                                                                                                                                                                                |
| 是否开启读写分离 backend-master-only                                                | Proxy集群实例开启读写分离（backend-master-only为no）。                                                                                                                      | - Proxy集群实例开启读写分离后，如果其他读请求配置项均未开启/配置时，默认由从节点处理读请求。  - Proxy集群实例开启读写分离后，如果开启/配置了其他读请求配置项，需要依次根据是否开启读指定（keys）命令只读备节点、ACL账号只读路由策略和read-only-slave-when-wr-split参数配置进行判断。   |
| 是否开启读写分离 backend-master-only                                                | 读写分离实例只有默认开启读写分离一种状态，没有配置参数。                                                                                                                                  | - 其他读请求配置项均未开启/配置时，默认由从节点处理读请求。  - 如果开启/配置了其他读请求配置项，需要依次根据是否开启指定（keys）命令只读备节点、ACL账号只读路由策略和read-only-slave-when-wr-split参数配置进行判断。                                        |
| 指定（keys）命令只读备节点 support-dispatch-to-replica-list                            | 默认配置为空。                                                                                                                                                       | -                                                                                                                                                                                                                                                                                                                                                |
| 指定（keys）命令只读备节点 support-dispatch-to-replica-list                            | 在support-dispatch-to-replica-list参数中配置keys。                                                                                                                   | 执行keys命令时，只在从节点执行。                                                                                                                                                                                                                                                                                                                               |
| ACL账号只读路由策略                                                             | 创建ACL账号时未配置只读路由策略（只读路由策略关闭）。                                                                                                                                  | -                                                                                                                                                                                                                                                                                                                                                |
| ACL账号只读路由策略                                                             | 创建ACL账号时配置了只读路由策略为主节点、备节点或主备节点。 配置方式请参考[配置Redis ACL访问账号](https://support.huaweicloud.com/usermanual-dcs/dcs-ug-221220.html)。 | 使用该ACL账号时，读请求根据配置自动分配到主节点、备节点或主备节点。 该配置项优先级小于指定（keys）命令只读备节点，如果指定了keys命令只读备节点，keys命令会先根据指定的规则分配读请求。                                                                                                                                                                                                            |
| 读写分离转发策略 read-only-slave-when-wr-split  | 默认仅在从节点进行读操作（read-only-slave-when-wr-split为yes。）                                                                                                              | 仅在slave节点进行读操作。 未配置其他读请求配置项时，默认根据该规则进行读操作。                                                                                                                                                                                                                                                                        |
| 读写分离转发策略 read-only-slave-when-wr-split  | 在主节点和从节点都可以进行读操作（read-only-slave-when-wr-split为no）。                                                                                                           | 在主节点和从节点都可以进行读操作。 未配置其他读请求配置项时，默认根据该规则进行读操作。                                                                                                                                                                                                                                                                   |
   
#### 相关文档
- 支持通过API查询实例配置参数，具体操作，请参见[查询实例配置参数](https://support.huaweicloud.com/api-dcs/ListConfigurations.html)。
- 支持通过API修改实例配置参数，具体操作，请参见[修改实例配置参数](https://support.huaweicloud.com/api-dcs/UpdateConfigurations.html)。
 
