# 实例受限使用命令
Cluster集群实例支持多个Key，但不支持跨slot访问的Redis命令。受限使用的命令如[表1]。
Proxy集群实例支持多Key的命令中，部分命令不支持跨slot访问，请参考[表3]。受限使用的命令如[表2]。
读写分离实例受限使用的命令，如[表4]。
![](https://support.huaweicloud.com/productdesc-dcs/public_sys-resources/note_3.0-zh-cn.png)
当用户执行比较耗时的命令（如flushall）时，可能会导致缓存实例在命令执行期间对外不响应用户的其它命令，造成状态监控失效，此时Console上缓存实例的状态会变成异常，命令执行结束后，实例状态会恢复正常。
#### Cluster集群实例受限使用的Redis命令
 表1Cluster集群实例受限使用的Redis命令 
| 命令类型        | 命令描述                                                                     |
|:---|:---|
| **Set**（集合）                                                                           ||
| SINTER      | 返回一个集合的全部成员，该集合是所有给定集合的交集                                                |
| SINTERSTORE | 类似SINTER，但结果保存到destination集合                                             |
| SUNION      | 返回一个集合的全部成员，该集合是所有给定集合的并集                                                |
| SUNIONSTORE | 和SUNION类似，但它将结果保存到destination集合                                          |
| SDIFF       | 返回一个集合的全部成员，该集合是所有给定集合之间的差集                                              |
| SDIFFSTORE  | 和SDIFF类似，但它将结果保存到destination集合                                           |
| SMOVE       | 将member元素从source集合移动到destination集合                                       |
| **SortedSet**（有序集合）                                                                   ||
| ZUNIONSTORE | 计算给定的一个或多个有序集的并集                                                         |
| ZINTERSTORE | 计算给定的一个或多个有序集的交集                                                         |
| **HyperLogLog**                                                                       ||
| PFCOUNT     | 返回储存在给定键（或多个键）的HyperLogLog的近似基数                                          |
| PFMERGE     | 将多个HyperLogLog合并（merge）为一个HyperLogLog                                    |
| **Keys**（键）                                                                           ||
| RENAME      | 将key改名                                                                   |
| RENAMENX    | 将key改名，新key必须是之前不存在的                                                     |
| BITOP       | 对一个或多个保存二进制位的字符串key进行位元操作，并将结果保存到destkey上                                |
| RPOPLPUSH   | 返回并移除存储在source的列表的最后一个元素（列表尾部元素）， 并把该元素放入存储在destination的列表的第一个元素位置（列表头部） |
| **String**（字符串）                                                                       ||
| MSETNX      | 同时设置一个或多个key-value对                                                      |
   
#### Proxy集群实例受限使用的Redis命令
 表2Proxy集群实例受限使用的Redis命令 
| 命令类型                                                      | 命令                  | 受限使用条件                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|:---|:---|:---|
| Set（集合）                                                   | SMOVE               | proxy集群要求源key和目标key在同一个slot。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Sorted Set（有序集合）  | BZPOPMAX            | Proxy集群实例要求传入的key都在同一个slot中。 Redis 4.0 Proxy集群实例不支持。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Sorted Set（有序集合）  | BZPOPMIN            | Proxy集群实例要求传入的key都在同一个slot中。 Redis 4.0 Proxy集群实例不支持。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| GEO（地理位置）                                                 | GEORADIUS           | - Proxy集群实例要求传入的key都在同一个slot中。  - Proxy集群的多DB模式下暂不支持带STORE参数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| GEO（地理位置）                                                 | GEORADIUSBYMEMBER   | - Proxy集群实例要求传入的key都在同一个slot中。  - Proxy集群的多DB模式下暂不支持带STORE参数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| GEO（地理位置）                                                 | GEOSEARCHSTORE      | - Proxy集群实例要求传入的key都在同一个slot中。  - Proxy集群的多DB模式下暂不支持带STORE参数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Connection（连接）                                            | CLIENT KILL         | - 仅支持两种形式： - CLIENT KILL ip:port  - CLIENT KILL ADDR ip:port    - id字段为随机值，不满足idc1\<idc2→Tc1\<Tc2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Connection（连接）                                            | CLIENT LIST         | - 仅支持两种形式： - CLIENT LIST  - CLIENT LIST \[TYPE normal\|master\|replica\|pubsub\]    - id字段为随机值，不满足idc1\<idc2→Tc1\<Tc2                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Connection（连接）                                            | SELECT index        | Proxy集群的多DB支持当前通过改key实现，不推荐使用该方案。 Proxy集群支持多DB限制请参考[Proxy集群使用多DB限制](https://support.huaweicloud.com/dcs_faq/dcs-faq-210804001.html)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| HyperLogLog                                               | PFCOUNT             | Proxy集群实例要求传入的key都在同一个slot中。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| HyperLogLog                                               | PFMERGE             | Proxy集群实例要求传入的key都在同一个slot中。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Keys（键）         | RENAME              | Proxy集群实例要求传入的key都在同一个slot中。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Keys（键）         | RENAMENX            | Proxy集群实例要求传入的key都在同一个slot中。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Keys（键）         | SCAN                | - Proxy集群实例不支持在事务中使用SCAN命令。  - Proxy集群SCAN命令支持指定分片：在命令后面添加 ip:port。(执行**icluster nodes** 命令可以查询不同分片的IP地址及端口。) 如果执行SCAN命令指定分片未能返回需要信息，可能是因为您的Proxy集群的Proxy节点为老版本，请联系客服升级Proxy版本。 ``` icluster nodes xxx 192.168.00.00:1111@xxx xxx connected 10923-16383 xxx 192.168.00.01:2222@xxx xxx connected 0-5460 xxx 192.168.00.02:3333@xxx xxx connected 5461-10922 SCAN 0 match * COUNT 5 192.168.00.02:3333 1) "0" 2) 1) "key1" 2) "key2" 3) "key3" 4) "key4" 5) "key5" ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Lists（列表）                                                 | BLPOP               | Proxy集群实例要求传入的key都在同一个slot中。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Lists（列表）                                                 | BRPOP               | Proxy集群实例要求传入的key都在同一个slot中。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Lists（列表）                                                 | BRPOPLPUSH          | Proxy集群实例要求传入的key都在同一个slot中。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Pub/Sub（发布/订阅）                                            | PSUBSCRIBE          | Proxy集群事件订阅，不支持键空间事件订阅，键空间事件订阅虽不会失败，但功能本身不支持。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Scripting（脚本）                                             | EVAL                | - Proxy集群实例要求传入的key都在同一个slot中。  - Proxy集群开启多DB时，KEYS参数会被修改，Lua脚本中使用到KEYS的地方需要注意。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| Scripting（脚本）                                             | EVALSHA             | - Proxy集群实例要求传入的key都在同一个slot中。  - Proxy集群开启多DB时，KEYS参数会被修改，Lua脚本中使用到KEYS的地方需要注意。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| Server（服务器）                                               | MEMORY DOCTOR       | Proxy集群要在命令后面加上节点的ip:port。 获取节点IP和端口的方式请参考（以MEMORY USAGE为例）： 1. 执行命令**cluster keyslot *key***查询key所在的slot号。  2. 执行**icluster nodes** 查询不同slot区间对应的IP地址及端口，获取key值对应slot号区间对应的IP和端口。 如果执行**icluster nodes** 未能返回需要信息，可能是因为您的Proxy集群实例为老版本，请执行**cluster nodes**重新查询。   3. 当Proxy集群开启了多DB： proxy小版本大于等于5.0.14.19时，执行**MEMORY *key ip:port***； 否则执行**MEMORY *xxx:As{key} ip:port***，其中xxx为key值所在的DB，例如DB0，DB1，DB255分别对应000，001，255。 单DB Proxy集群实例示例如下： ``` set key1 value1 OK get key1 value1 cluster keyslot key1 9189 icluster nodes xxx 192.168.00.00:1111@xxx xxx connected 10923-16383 xxx 192.168.00.01:2222@xxx xxx connected 0-5460 xxx 192.168.00.02:3333@xxx xxx connected 5461-10922 MEMORY USAGE key1 192.168.00.02:3333 54 ```    |
| Server（服务器）                                               | MEMORY HELP         | Proxy集群要在命令后面加上节点的ip:port。 获取节点IP和端口的方式请参考（以MEMORY USAGE为例）： 1. 执行命令**cluster keyslot *key***查询key所在的slot号。  2. 执行**icluster nodes** 查询不同slot区间对应的IP地址及端口，获取key值对应slot号区间对应的IP和端口。 如果执行**icluster nodes** 未能返回需要信息，可能是因为您的Proxy集群实例为老版本，请执行**cluster nodes**重新查询。   3. 当Proxy集群开启了多DB： proxy小版本大于等于5.0.14.19时，执行**MEMORY *key ip:port***； 否则执行**MEMORY *xxx:As{key} ip:port***，其中xxx为key值所在的DB，例如DB0，DB1，DB255分别对应000，001，255。 单DB Proxy集群实例示例如下： ``` set key1 value1 OK get key1 value1 cluster keyslot key1 9189 icluster nodes xxx 192.168.00.00:1111@xxx xxx connected 10923-16383 xxx 192.168.00.01:2222@xxx xxx connected 0-5460 xxx 192.168.00.02:3333@xxx xxx connected 5461-10922 MEMORY USAGE key1 192.168.00.02:3333 54 ```    |
| Server（服务器）                                               | MEMORY MALLOC-STATS | Proxy集群要在命令后面加上节点的ip:port。 获取节点IP和端口的方式请参考（以MEMORY USAGE为例）： 1. 执行命令**cluster keyslot *key***查询key所在的slot号。  2. 执行**icluster nodes** 查询不同slot区间对应的IP地址及端口，获取key值对应slot号区间对应的IP和端口。 如果执行**icluster nodes** 未能返回需要信息，可能是因为您的Proxy集群实例为老版本，请执行**cluster nodes**重新查询。   3. 当Proxy集群开启了多DB： proxy小版本大于等于5.0.14.19时，执行**MEMORY *key ip:port***； 否则执行**MEMORY *xxx:As{key} ip:port***，其中xxx为key值所在的DB，例如DB0，DB1，DB255分别对应000，001，255。 单DB Proxy集群实例示例如下： ``` set key1 value1 OK get key1 value1 cluster keyslot key1 9189 icluster nodes xxx 192.168.00.00:1111@xxx xxx connected 10923-16383 xxx 192.168.00.01:2222@xxx xxx connected 0-5460 xxx 192.168.00.02:3333@xxx xxx connected 5461-10922 MEMORY USAGE key1 192.168.00.02:3333 54 ```    |
| Server（服务器）                                               | MEMORY PURGE        | Proxy集群要在命令后面加上节点的ip:port。 获取节点IP和端口的方式请参考（以MEMORY USAGE为例）： 1. 执行命令**cluster keyslot *key***查询key所在的slot号。  2. 执行**icluster nodes** 查询不同slot区间对应的IP地址及端口，获取key值对应slot号区间对应的IP和端口。 如果执行**icluster nodes** 未能返回需要信息，可能是因为您的Proxy集群实例为老版本，请执行**cluster nodes**重新查询。   3. 当Proxy集群开启了多DB： proxy小版本大于等于5.0.14.19时，执行**MEMORY *key ip:port***； 否则执行**MEMORY *xxx:As{key} ip:port***，其中xxx为key值所在的DB，例如DB0，DB1，DB255分别对应000，001，255。 单DB Proxy集群实例示例如下： ``` set key1 value1 OK get key1 value1 cluster keyslot key1 9189 icluster nodes xxx 192.168.00.00:1111@xxx xxx connected 10923-16383 xxx 192.168.00.01:2222@xxx xxx connected 0-5460 xxx 192.168.00.02:3333@xxx xxx connected 5461-10922 MEMORY USAGE key1 192.168.00.02:3333 54 ```    |
| Server（服务器）                                               | MEMORY STATS        | Proxy集群要在命令后面加上节点的ip:port。 获取节点IP和端口的方式请参考（以MEMORY USAGE为例）： 1. 执行命令**cluster keyslot *key***查询key所在的slot号。  2. 执行**icluster nodes** 查询不同slot区间对应的IP地址及端口，获取key值对应slot号区间对应的IP和端口。 如果执行**icluster nodes** 未能返回需要信息，可能是因为您的Proxy集群实例为老版本，请执行**cluster nodes**重新查询。   3. 当Proxy集群开启了多DB： proxy小版本大于等于5.0.14.19时，执行**MEMORY *key ip:port***； 否则执行**MEMORY *xxx:As{key} ip:port***，其中xxx为key值所在的DB，例如DB0，DB1，DB255分别对应000，001，255。 单DB Proxy集群实例示例如下： ``` set key1 value1 OK get key1 value1 cluster keyslot key1 9189 icluster nodes xxx 192.168.00.00:1111@xxx xxx connected 10923-16383 xxx 192.168.00.01:2222@xxx xxx connected 0-5460 xxx 192.168.00.02:3333@xxx xxx connected 5461-10922 MEMORY USAGE key1 192.168.00.02:3333 54 ```    |
| Server（服务器）                                               | MEMORY USAGE        | Proxy集群要在命令后面加上节点的ip:port。 获取节点IP和端口的方式请参考（以MEMORY USAGE为例）： 1. 执行命令**cluster keyslot *key***查询key所在的slot号。  2. 执行**icluster nodes** 查询不同slot区间对应的IP地址及端口，获取key值对应slot号区间对应的IP和端口。 如果执行**icluster nodes** 未能返回需要信息，可能是因为您的Proxy集群实例为老版本，请执行**cluster nodes**重新查询。   3. 当Proxy集群开启了多DB： proxy小版本大于等于5.0.14.19时，执行**MEMORY *key ip:port***； 否则执行**MEMORY *xxx:As{key} ip:port***，其中xxx为key值所在的DB，例如DB0，DB1，DB255分别对应000，001，255。 单DB Proxy集群实例示例如下： ``` set key1 value1 OK get key1 value1 cluster keyslot key1 9189 icluster nodes xxx 192.168.00.00:1111@xxx xxx connected 10923-16383 xxx 192.168.00.01:2222@xxx xxx connected 0-5460 xxx 192.168.00.02:3333@xxx xxx connected 5461-10922 MEMORY USAGE key1 192.168.00.02:3333 54 ```    |
| Server（服务器）                                               | MONITOR             | Proxy集群要在命令后面加上节点的ip:port。 获取节点IP和端口的方式请参考（以MEMORY USAGE为例）： 1. 执行命令**cluster keyslot *key***查询key所在的slot号。  2. 执行**icluster nodes** 查询不同slot区间对应的IP地址及端口，获取key值对应slot号区间对应的IP和端口。 如果执行**icluster nodes** 未能返回需要信息，可能是因为您的Proxy集群实例为老版本，请执行**cluster nodes**重新查询。   3. 当Proxy集群开启了多DB： proxy小版本大于等于5.0.14.19时，执行**MEMORY *key ip:port***； 否则执行**MEMORY *xxx:As{key} ip:port***，其中xxx为key值所在的DB，例如DB0，DB1，DB255分别对应000，001，255。 单DB Proxy集群实例示例如下： ``` set key1 value1 OK get key1 value1 cluster keyslot key1 9189 icluster nodes xxx 192.168.00.00:1111@xxx xxx connected 10923-16383 xxx 192.168.00.01:2222@xxx xxx connected 0-5460 xxx 192.168.00.02:3333@xxx xxx connected 5461-10922 MEMORY USAGE key1 192.168.00.02:3333 54 ```    |
| Strings（字符串）                                              | BITOP               | Proxy集群实例要求传入的key都在同一个slot中。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Strings（字符串）                                              | MSETNX              | Proxy集群实例要求传入的key都在同一个slot中。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Transactions（事务）                                          | WATCH               | Proxy集群实例要求传入的key都在同一个slot中。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Transactions（事务）                                          | MULTI               | 不保证事务中跨slot命令的有序性。 事务中禁用的命令：WATCH，MONITOR，RANDOMKEY，KEYS，SCAN，SUBSCRIBE，UNSUBSCRIBE，PSUBSCRIBE，PUNSUBSCRIBE，SCRIPT，EVAL，EVALSHA，DBSIZE，AUTH，FLUSHDB，FLUSHALL，CLIENT，MEMORY，SSUBSCRIBE，SUNSUBSCRIBE，PUBSUB，EVAL_RO，EVALSHA_RO，FUNCTION，FCALL，FCALL_RO                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| Transactions（事务）                                          | EXEC                | 不保证事务中跨slot命令的有序性。 事务中禁用的命令：WATCH，MONITOR，RANDOMKEY，KEYS，SCAN，SUBSCRIBE，UNSUBSCRIBE，PSUBSCRIBE，PUNSUBSCRIBE，SCRIPT，EVAL，EVALSHA，DBSIZE，AUTH，FLUSHDB，FLUSHALL，CLIENT，MEMORY，SSUBSCRIBE，SUNSUBSCRIBE，PUBSUB，EVAL_RO，EVALSHA_RO，FUNCTION，FCALL，FCALL_RO                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| Streams（流）        | XREAD               | Proxy集群实例要求传入的key都在同一个slot中。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Streams（流）        | XREADGROUP          | Proxy集群实例要求传入的key都在同一个slot中。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
   
 #### Proxy集群多Key命令说明
 表3Proxy集群多Key命令说明 
| 类型              | 命令                                                                                                                                                                                                                                                                                                         |
|:---|:---|
| 支持跨slot的多Key命令  | DEL、MGET、MSET、EXISTS、SUNION、SINTER、SDIFF、SUNIONSTORE、SINTERSTORE、SDIFFSTORE、ZUNIONSTORE、ZINTERSTORE                                                                                                                                                                                                        |
| 不支持跨slot的多Key命令 | SMOVE、SORT、BITOP、MSETNX、RENAME、RENAMENX、BLPOP、BRPOP、RPOPLPUSH、BRPOPLPUSH、PFMERGE、PFCOUNT、BLMOVE、COPY、GEOSEARCHSTORE、LMOVE、ZRANGESTORE、XREAD、XREADGROUP、FCALL、FCALL_RO、FUNCTION DELETE、FUNCTION DUMP、FUNCTION FLUSH、FUNCTION HELP、FUNCTION KILL、FUNCTION LIST、FUNCTION LOAD、FUNCTION RESTORE、FUNCTION STATS |
   
#### 读写分离实例受限使用的Redis命令
 表4读写分离实例受限使用的Redis命令 
| 命令类型           | 命令          | 受限使用条件                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|:---|:---|:---|
| Connection（连接） | CLIENT KILL | - 仅支持两种形式： - CLIENT KILL ip:port  - CLIENT KILL ADDR ip:port    - id字段为随机值，不满足idc1\<idc2→Tc1\<Tc2                       |
| Connection（连接） | CLIENT LIST | - 仅支持两种形式： - CLIENT LIST  - CLIENT LIST \[TYPE normal\|master\|replica\|pubsub\]    - id字段为随机值，不满足idc1\<idc2→Tc1\<Tc2   |