ACL CAT [categoryname]

从 6.0.0 开始可用。

时间复杂度： O(1)，因为类别和命令是固定的。

如果调用不带参数，该命令将显示可用的 ACL 类别。如果给出了类别名称，该命令将显示指定类别中的所有 Redis 命令。

ACL 类别对于创建一次包含或排除大量命令的 ACL 规则非常有用，而无需指定每个命令。例如，以下规则将允许用户karin执行除可能影响服务器稳定性的最危险操作之外的所有操作：

ACL SETUSER karin on +@all -@dangerous

我们首先将所有命令添加到karin能够执行的命令集中，然后删除所有危险命令。

检查所有可用类别非常简单：

> ACL CAT
 1) "keyspace"
 2) "read"
 3) "write"
 4) "set"
 5) "sortedset"
 6) "list"
 7) "hash"
 8) "string"
 9) "bitmap"
10) "hyperloglog"
11) "geo"
12) "stream"
13) "pubsub"
14) "admin"
15) "fast"
16) "slow"
17) "blocking"
18) "dangerous"
19) "connection"
20) "transaction"
21) "scripting"

然后我们可能想知道哪些命令属于给定类别：

> ACL CAT dangerous
 1) "flushdb"
 2) "acl"
 3) "slowlog"
 4) "debug"
 5) "role"
 6) "keys"
 7) "pfselftest"
 8) "client"
 9) "bgrewriteaof"
10) "replicaof"
11) "monitor"
12) "restore-asking"
13) "latency"
14) "replconf"
15) "pfdebug"
16) "bgsave"
17) "sync"
18) "config"
19) "flushall"
20) "cluster"
21) "info"
22) "lastsave"
23) "slaveof"
24) "swapdb"
25) "module"
26) "restore"
27) "migrate"
28) "save"
29) "shutdown"
30) "psync"
31) "sort"

返回值

数组回复：ACL 类别列表或给定类别内的命令列表。如果作为参数给出了无效的类别名称，该命令可能会返回错误。

ACL DELUSER username [username ...]

从 6.0.0 开始可用。

时间复杂度：考虑到典型用户的 O(1) 摊销时间。

删除所有指定的 ACL 用户并终止所有通过此类用户身份验证的连接。注意：特殊default用户不能从系统中删除，这是每个新连接都经过身份验证的默认用户。用户列表中可能包含不存在的用户名，在这种情况下，不对不存在的用户执行任何操作。

返回值

整数回复：被删除的用户数。由于某些用户可能不存在，因此该数字并不总是与参数的数量相匹配。

例子

> ACL DELUSER antirez
1

ACL DRYRUN username command [arg [arg ...]]

自 7.0.0 起可用。

时间复杂度： O(1)。

模拟给定用户对给定命令的执行。此命令可用于测试给定用户的权限，而无需启用用户或导致运行命令的副作用。

返回值

简单的字符串回复：OK成功。 批量字符串回复：描述用户无法执行命令的原因的错误。

例子

> ACL SETUSER VIRGINIA +SET ~*
"OK"
> ACL DRYRUN VIRGINIA SET foo bar
"OK"
> ACL DRYRUN VIRGINIA GET foo bar
"This user has no permissions to run the 'GET' command"

ACL GENPASS [bits]

从 6.0.0 开始可用。

时间复杂度： O(1)

ACL 用户需要一个可靠的密码才能在没有安全风险的情况下对服务器进行身份验证。这样的密码不需要人类记住，而只需要计算机记住，因此它可能非常长且强度高（外部攻击者无法猜测）。如果可用，ACL GENPASS命令会生成从 /dev/urandom 开始的密码，否则（在没有 /dev/urandom 的系统中）它使用较弱的系统，这可能比手动选择弱密码更好。

默认情况下（如果 /dev/urandom 可用）密码是强密码并且可以在 Redis 应用程序的上下文中用于其他用途，例如为了创建唯一的会话标识符或其他类型的不可猜测且不冲突的 ID。密码生成也非常便宜，因为我们并没有在每次执行时真正向 /dev/urandom 询问位。在启动时，Redis 使用 /dev/urandom 创建一个种子，然后它将在计数器模式下使用 SHA256，以 HMAC-SHA256(seed,counter) 作为原语，以便根据需要创建更多随机字节。这意味着应用程序开发人员应该可以随意滥用ACL GENPASS来根据需要创建尽可能多的安全伪随机字符串。

命令输出是二进制字符串的十六进制表示。默认情况下，它发出 256 位（即 64 个十六进制字符）。用户可以提供从 1 到 1024 发出的位数形式的参数，以更改输出长度。请注意，提供的位数总是四舍五入到下一个 4 的倍数。因此，例如，仅要求 1 位密码将导致以单个十六进制字符的形式发出 4 位。

返回值

批量字符串回复：默认为 64 字节字符串，代表 256 位伪随机数据。否则，如果需要参数，则输出字符串长度是指定位数（四舍五入到 4 的下一个倍数）除以 4。

例子

> ACL GENPASS
"dd721260bfe1b3d9601e7fbab36de6d04e2e67b0ef1c53de59d45950db0dd3cc"

> ACL GENPASS 32
"355ef3dd"

> ACL GENPASS 5
"90"

ACL GETUSER username

从 6.0.0 开始可用。

时间复杂度： O(N)。其中 N 是用户拥有的密码、命令和模式规则的数量。

该命令返回为现有 ACL 用户定义的所有规则。

具体来说，它列出了用户的 ACL 标志、密码哈希、命令、密钥模式、通道模式（在 6.2 版中添加）和选择器（在 7.0 版中添加）。如果向用户添加更多元数据，将来可能会返回其他信息。

命令规则始终以与ACL SETUSER命令中使用的格式相同的格式返回。在 7.0 版之前，键和通道作为模式数组返回，但是在 7.0 版之后，它们现在也以与ACL SETUSER命令中使用的格式相同的格式返回。注意：此命令规则的描述反映了用户的有效权限，因此虽然它可能与用于配置用户的规则集不同，但在功能上仍然相同。

选择器按照它们应用于用户的顺序列出，并包括有关命令、键模式和通道模式的信息。

数组回复：用户的 ACL 规则定义列表。

如果user不存在，则返回Null 回复。

例子

这是用户的示例配置

> ACL SETUSER sample on nopass +GET allkeys &* (+SET ~key2)
"OK"
> ACL GETUSER sample
1) "flags"
2) 1) "on"
   2) "allkeys"
   3) "nopass"
3) "passwords"
4) (empty array)
5) "commands"
6) "+@all"
7) "keys"
8) "~*"
9) "channels"
10) "&*"
11) "selectors"
12) 1) 1) "commands"
       6) "+SET"
       7) "keys"
       8) "~key2"
       9) "channels"
       10) "&*"

历史

• Redis 版本 >= 6.2.0：添加了 Pub/Sub 频道模式。
• Redis 版本 >= 7.0.0：添加了选择器并将键和通道模式的格式从列表更改为它们的规则表示。

ACL LIST

从 6.0.0 开始可用。

时间复杂度： O(N)。其中 N 是配置的用户数。

该命令显示 Redis 服务器中当前活动的 ACL 规则。返回数组中的每一行定义一个不同的用户，格式与 redis.conf 文件或外部 ACL 文件中使用的格式相同，因此您可以将 ACL LIST 命令返回的内容直接剪切并粘贴到配置文件中，如果你希望（但一定要检查ACL SAVE）。

返回值

字符串数组。

例子

> ACL LIST
1) "user antirez on #9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08 ~objects:* &* +@all -@admin -@dangerous"
2) "user default on nopass ~* &* +@all"

ACL LOAD

从 6.0.0 开始可用。

时间复杂度： O(N)。其中 N 是配置的用户数。

当 Redis 配置为使用 ACL 文件（带有aclfile配置选项）时，此命令将从文件中重新加载 ACL，将所有当前 ACL 规则替换为文件中定义的规则。该命令确保具有全有或全无行为，即：

• 如果文件中的每一行都有效，则加载所有 ACL。
• 如果文件中的一行或多行无效，则不加载任何内容，并继续使用服务器内存中定义的旧 ACL 规则。

返回值

简单的字符串回复：OK成功。

该命令可能由于以下几个原因而失败并出现错误：如果文件不可读，如果文件内部有错误，在这种情况下，错误将在错误中报告给用户。最后，如果服务器未配置为使用外部 ACL 文件，该命令将失败。

例子

> ACL LOAD
+OK

> ACL LOAD
-ERR /tmp/foo:1: Unknown command or category name in ACL...

ACL LOG [count|RESET]

从 6.0.0 开始可用。

时间复杂度： O(N)，其中 N 是显示的条目数。

该命令显示最近 ACL 安全事件的列表：

1. 未能通过AUTH或HELLO验证他们的连接。
2. 命令被拒绝，因为违反了当前的 ACL 规则。
3. 命令被拒绝，因为当前 ACL 规则中不允许访问密钥。

可选参数指定要显示的条目数。默认情况下，最多返回十个失败。特殊的RESET参数清除日志。条目从最近的开始显示。

返回值

调用以显示安全事件时：

数组回复：ACL 安全事件列表。

当使用RESET调用时：

简单字符串回复：OK如果安全日志被清除。

例子

> AUTH someuser wrongpassword
(error) WRONGPASS invalid username-password pair
> ACL LOG 1
1)  1) "count"
    2) (integer) 1
    3) "reason"
    4) "auth"
    5) "context"
    6) "toplevel"
    7) "object"
    8) "AUTH"
    9) "username"
   10) "someuser"
   11) "age-seconds"
   12) "4.0960000000000001"
   13) "client-info"
   14) "id=6 addr=127.0.0.1:63026 fd=8 name= age=9 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=48 qbuf-free=32720 obl=0 oll=0 omem=0 events=r cmd=auth user=default"

ACL SAVE

从 6.0.0 开始可用。

时间复杂度： O(N)。其中 N 是配置的用户数。

当 Redis 配置为使用 ACL 文件（带有aclfile配置选项）时，该命令会将当前定义的 ACL 从服务器内存保存到 ACL 文件中。

返回值

简单的字符串回复：OK成功。

该命令可能因以下几个原因而失败并出现错误：如果无法写入文件或服务器未配置为使用外部 ACL 文件。

例子

> ACL SAVE
+OK

> ACL SAVE
-ERR There was an error trying to save the ACLs. Please check the server logs for more information

ACL SETUSER username [rule [rule ...]]

从 6.0.0 开始可用。

时间复杂度： O(N)。其中 N 是提供的规则数。

创建具有指定规则的 ACL 用户或修改现有用户的规则。这是交互操作 Redis ACL 用户的主界面：如果用户名不存在，该命令将创建没有任何权限的用户名，然后从左到右读取作为连续参数提供的所有规则，将用户 ACL 规则设置为指定的。

如果用户已经存在，除了已经设置的规则之外，只应用提供的 ACL 规则 。例如：

ACL SETUSER virginia on allkeys +set

上面的命令将创建一个被称为virginia活动的用户（on 规则），可以访问任何键（allkeys 规则），并且可以调用 set 命令（+set 规则）。然后另一个 SETUSER 调用可以修改用户规则：

ACL SETUSER virginia +get

上述规则不会将新规则应用于用户 virginia，因此除了SET之外，用户 virginia 现在还可以使用GET命令。

从 Redis 7.0 开始，ACL 规则也可以分为多个不同的规则集，称为选择器。通过将规则包装在括号中并像任何其他规则一样提供它们来添加选择器。为了执行命令，root 权限（括号外定义的规则）或任何选择器（括号内定义的规则）必须与给定命令匹配。例如：

ACL SETUSER virginia on +GET allkeys (+SET ~app1*)

这为用户设置了两组权限，一组在用户上定义，一组在选择器上定义。root 用户权限只允许执行 get 命令，但可以在任何键上执行。然后选择器授予第二组权限：访问要在以“app1”开头的任何键上执行的SET命令。使用多个选择器允许您根据访问的键授予不同的权限。

当我们想确保从头开始定义一个用户，而不关心它之前是否定义了关联的规则时，我们可以使用特殊规则 reset作为第一条规则，以刷新所有其他现有规则：

ACL SETUSER antirez reset [... other rules ...]

重置用户后，它返回到刚创建时的状态：非活动（关闭规则），无法执行任何命令，无法访问任何键：

> ACL SETUSER antirez reset
+OK
> ACL LIST
1) "user antirez off -@all"

ACL 规则可以是诸如“on”、“off”、“reset”、“allkeys”之类的词，也可以是以特殊字符开头并后跟另一个字符串（中间没有任何空格）的特殊规则，例如“+放”。

以下文档是有关此命令功能的参考手册，但是我们的ACL 教程可能会更温和地介绍 ACL 系统的一般工作原理。

规则列表

Redis ACL 规则分为两类：定义命令权限的规则“命令规则”和定义用户状态的规则“用户管理规则”。这是所有受支持的 Redis ACL 规则的列表：

命令规则

• ~：将指定的键模式（glob 样式模式，如在KEYS命令中）添加到用户可访问的键模式列表中。这将授予与模式匹配的键的读取和写入权限。您可以为同一用户添加多个键模式。例子：~objects:*
• %R~：（Redis 7.0 及更高版本可用）添加指定的读取密钥模式。这与常规键模式的行为类似，但仅授予从与给定模式匹配的键中读取的权限。有关详细信息，请参阅密钥权限。
• %W~：（Redis 7.0 及更高版本可用）添加指定的写入键模式。这与常规密钥模式的行为相似，但仅授予写入与给定模式匹配的密钥的权限。有关详细信息，请参阅密钥权限。
• %RW~: （在 Redis 7.0 及更高版本中可用）~.
• allkeys: 的别名~*，它允许用户访问所有密钥。
• resetkeys：从用户可以访问的键模式列表中删除所有键模式。
• &：（在 Redis 6.2 及更高版本中可用）将指定的 glob 样式模式添加到用户可访问的 Pub/Sub 通道模式列表中。您可以为同一用户添加多个频道模式。例子：&chatroom:*
• allchannels: 的别名&*，它允许用户访问所有 Pub/Sub 频道。
• resetchannels：从用户可以访问的 Pub/Sub 频道模式列表中删除所有频道模式。
• +：将命令添加到用户可以调用的命令列表中。可|用于允许子命令（例如“+config|get”）。
• +@：将指定类别中的所有命令添加到用户能够执行的命令列表中。示例：（+@string添加所有字符串命令）。有关类别列表，请检查ACL CAT命令。
• +|first-arg：允许其他禁用命令的特定第一个参数。它仅在没有子命令的命令上受支持，并且不允许像 -SELECT|1 这样的否定形式，只能以“+”开头的加法。此功能已弃用，将来可能会被删除。
• allcommands: 的别名+@all。添加服务器中的所有命令，包括将来通过模块加载的命令，由该用户执行。
• -：将命令删除到用户可以调用的命令列表中。从 Redis 7.0 开始，它可以|用于阻止子命令（例如“-config|set”）。
• -@：喜欢+@但删除类别中的所有命令而不是添加它们。
• nocommands: 的别名-@all。删除所有命令，用户将无法再执行任何操作。

用户管理规则

• on: 将用户设置为活动用户，可以使用AUTH .
• off: 将用户设置为非活动用户，将无法以该用户身份登录。请注意，如果用户在已与该用户进行身份验证的连接之后被禁用（设置为关闭），则连接将继续按预期工作。要同时终止旧连接，您可以将CLIENT KILL与用户选项一起使用。另一种方法是使用ACL DELUSER删除用户，这将导致所有作为已删除用户身份验证的连接都被断开。
• nopass：用户设置为“无密码”用户。这意味着可以使用任何密码对此类用户进行身份验证。默认情况下，default特殊用户设置为“nopass”。该nopass规则还将重置用户的所有配置密码。

• password：将指定的明文密码作为哈希密码添加到用户密码列表中。每个用户都可以有多个活动密码，因此密码轮换会更简单。指定的密码不会以明文形式存储在服务器内。示例：>mypassword。

• #：将指定的哈希密码添加到用户密码列表中。Redis 散列密码使用 SHA256 散列并转换为十六进制字符串。示例：#c3ab8ff13720e8ad9047dd39466b3c8974e592c2fa383d4a3960714caef0c4f2。
• <password: 喜欢>password但删除密码而不是添加密码。
• !: 喜欢#但删除密码而不是添加密码。
• ()：（在 Redis 7.0 及更高版本中可用）创建一个新的选择器来匹配规则。选择器在用户权限之后进行评估，并根据它们定义的顺序进行评估。如果命令匹配用户权限或任何选择器，则允许。有关更多信息，请参阅选择器。
• clearselectors：（在 Redis 7.0 及更高版本中可用）删除所有附加到用户的选择器。
• reset：删除用户的任何能力。设置为关闭，没有密码，无法执行任何命令，无法访问任何密钥。

返回值

简单的字符串回复：OK成功。

如果规则包含错误，则返回错误。

例子

> ACL SETUSER alan allkeys +@string +@set -SADD >alanpassword
+OK

> ACL SETUSER antirez heeyyyy
(error) ERR Error in ACL SETUSER modifier 'heeyyyy': Syntax error

历史

• Redis 版本 >= 6.2.0：添加了 Pub/Sub 频道模式。
• Redis 版本 >= 7.0.0：添加了选择器和基于键的权限。

ACL USERS

从 6.0.0 开始可用。

时间复杂度： O(N)。其中 N 是配置的用户数。

该命令显示 Redis ACL 系统中当前配置的用户的所有用户名列表。

返回值
字符串数组。

例子

> ACL USERS
1) "anna"
2) "antirez"
3) "default"

ACL WHOAMI

从 6.0.0 开始可用。

时间复杂度： O(1)

返回当前连接验证的用户名。新连接使用“默认”用户进行身份验证。他们可以使用AUTH更改用户。

返回值

批量字符串回复：当前连接的用户名。

例子

> ACL WHOAMI
"default"

BGREWRITEAOF

从 1.0.0 开始可用。

时间复杂度： O(1)

指示 Redis 启动Append Only File重写过程。重写将创建当前仅附加文件的小型优化版本。

如果BGREWRITEAOF失败，则不会丢失任何数据，因为旧的 AOF 将保持不变。

只有在没有后台进程进行持久化的情况下，才会由 Redis 触发重写。

具体来说：

• 如果 Redis 子进程正在磁盘上创建快照，则 AOF 重写会被安排，但直到生成 RDB 文件的保存子进程终止时才会开始。在这种情况下，BGREWRITEAOF仍将返回一个肯定的状态回复，但带有适当的消息。您可以通过查看Redis 2.6 或后续版本的INFO命令来检查是否计划了 AOF 重写。
• 如果 AOF 重写已在进行中，则该命令将返回错误，并且不会安排稍后的 AOF 重写。
• 如果 AOF 重写可以启动，但启动它的尝试失败（例如，由于创建子进程时出错），则将错误返回给调用者。

从 Redis 2.4 开始，AOF 重写由 Redis 自动触发，但是 BGREWRITEAOF命令可用于随时触发重写。

有关详细信息，请参阅持久性文档。

返回值

简单字符串回复：当调用成功执行时，表示重写开始或即将开始的简单字符串回复。

如上文所述，在某些情况下，该命令可能会返回错误消息。

BGSAVE [SCHEDULE]

从 1.0.0 开始可用。

时间复杂度： O(1)

在后台保存数据库。

通常会立即返回 OK 代码。Redis 分叉，父级继续为客户端提供服务，子级将数据库保存在磁盘上然后退出。

如果已经有后台保存正在运行，或者如果有另一个非后台保存进程正在运行，特别是正在进行的 AOF 重写，则会返回错误。

如果使用，该命令将在 AOF 重写正在进行时BGSAVE SCHEDULE立即返回，并安排后台保存在下一次​​机会运行。OK

客户端可以使用LASTSAVE 命令检查操作是否成功。

有关详细信息，请参阅持久性文档。

返回值

简单字符串回复：Background saving started如果BGSAVE正确启动或Background saving scheduled与SCHEDULE子命令一起使用。

历史

• Redis 版本 >= 3.2.2：添加了 SCHEDULE 选项。

COMMAND

自 2.8.13 起可用。

时间复杂度： O(N) 其中 N 是 Redis 命令的总数

返回一个包含每个 Redis 命令详细信息的数组。

COMMAND命令是自省的。它的回复描述了服务器可以处理的所有命令。Redis 客户端可以在握手期间调用它来获取服务器的运行时能力。

COMMAND还有几个子命令。有关详细信息，请参阅其子命令。

集群注意事项： 此命令对于支持集群的客户端特别有用。此类客户端必须识别命令中的键名，才能将请求路由到正确的分片。尽管大多数命令都接受一个键作为它们的第一个参数，但这条规则有很多例外。您可以调用COMMAND，然后将命令之间的映射与其各自的密钥规范规则缓存在客户端中。

它返回的回复是一个数组，每个命令都有一个元素。描述 Redis 命令的每个元素本身都表示为一个数组。

该命令的数组由固定数量的元素组成。数组中元素的确切数量取决于服务器的版本。

1. 姓名
2. 阿里蒂
3. 标志
4. 第一把钥匙
5. 最后一个键
6. 步
7. ACL 类别（从 Redis 6.0 开始）
8. 提示（从 Redis 7.0 开始）
9. 关键规范（从 Redis 7.0 开始）
10. 子命令（从 Redis 7.0 开始）

姓名

这是小写的命令名称。

注意： Redis 命令名称不区分大小写。

阿里蒂

Arity 是命令期望的参数数量。它遵循一个简单的模式：

• 正整数表示固定数量的参数。
• 负整数表示最少数量的参数。

命令 arity始终包括命令的名称本身（以及适用时的子命令）。

例子：

• GET的 arity 为2，因为该命令只接受一个参数并且始终具有格式GET key。
• MGET的元数为-2，因为该命令至少接受一个参数，但可能接受多个参数：MGET key1 [key2] [key3] ....

标志

命令标志是一个数组。它可以包含以下简单字符串（状态回复）：

• admin：该命令是一个管理命令。
• 问：即使在哈希槽迁移期间也允许该命令。此标志与 Redis 集群部署相关。
• 阻塞：该命令可能会阻塞请求的客户端。
• denyoom：如果服务器的内存使用率太高，该命令将被拒绝（请参阅maxmemory配置指令）。
• 快速：命令以恒定或 log(N) 时间运行。该标志用于通过LATENCY命令监控延迟。
• loading：在加载数据库时允许该命令。
• may_replicate：该命令可以复制到副本和 AOF。
• 可移动键：第一个键、最后一个键和步长值并不能确定所有键的位置。在这种情况下，客户端需要使用COMMAND GETKEYS或密钥规范。请参阅下面的更多细节。
• no_auth：执行命令不需要认证。
• no async loading：在异步加载期间该命令被拒绝（即当副本使用 disk-lessSWAPDB SYNC并允许访问旧数据集时）。
• 没有强制键：该命令可以接受键名参数，但这些不是强制的。
• no_multi：在事务的上下文中不允许该命令。
• noscript：不能从脚本或函数调用该命令。
• pubsub：该命令与Redis Pub/Sub相关。
• random：该命令返回随机结果，这是逐字脚本复制的一个问题。从 Redis 7.0 开始，这个标志是一个命令提示。
• readonly：该命令不修改数据。
• 脚本排序：从脚本调用时，命令的输出被排序。
• skip_monitor：该命令未显示在MONITOR的输出中。
• skip_slowlog：该命令未显示在SLOWLOG的输出中。从 Redis 7.0 开始，这个标志是一个命令提示。
• stale：当一个副本有过时的数据时，该命令是允许的。
• write：该命令可以修改数据。

可动键
考虑排序：

1) 1) "sort"
   2) (integer) -2
   3) 1) write
      2) denyoom
      3) movablekeys
   4) (integer) 1
   5) (integer) 1
   6) (integer) 1
   ...

一些 Redis 命令没有预先确定的关键位置或不容易找到。对于这些命令，movablekeys标志表示first key、last key和step值不足以找到所有键。

以下是几个具有可移动键标志的命令示例：

• SORT：可选的STORE、BY和GET修饰符后跟键名。
• ZUNION：numkeys参数指定数字键名称参数。
• MIGRATE：键出现KEYS关键字并且仅当第二个参数是空字符串时。

Redis 集群客户端需要使用以下其他措施来定位此类命令的键。

您可以使用COMMAND GETKEYS命令并让您的 Redis 服务器报告给定命令调用的所有键。

从 Redis 7.0 开始，客户端可以使用键规范来识别键名的位置。对于解析密钥规范的客户端，唯一需要使用COMMAND GETKEYS的命令是SORT和MIGRATE。

有关详细信息，请参阅关键规格页面。

第一把钥匙

此值标识命令的第一个键名参数的位置。对于大多数命令，第一个键的位置是 1。位置 0 始终是命令名称本身。

最后一个键

此值标识命令的最后一个键名参数的位置。Redis 命令通常接受一个、两个或多个键。

接受单个键的命令将第一个键和最后一个键都设置为 1。

接受两个键名参数的命令，例如BRPOPLPUSH、SMOVE和RENAME，会将这个值设置为它们的第二个键的位置。

接受任意数量的键的多键命令，例如MSET，使用值 -1。

步

该值是键所在的第一个键值和最后一个键值之间的步长或增量。

考虑以下两个示例：

1) 1) "mset"
   2) (integer) -3
   3) 1) write
      2) denyoom
   4) (integer) 1
   5) (integer) -1
   6) (integer) 2
   ...

1) 1) "mget"
   2) (integer) -2
   3) 1) readonly
      2) fast
   4) (integer) 1
   5) (integer) -1
   6) (integer) 1
   ...

步数允许我们找到MSET等命令的键位置。它的语法是MSET key1 val1 [key2] [val2] [key3] [val3]...，并且键在每个其他位置。因此，与使用步长值1的MGET不同，MSET使用2。

ACL 类别

这是一个简单字符串数组，它们是命令所属的 ACL 类别。请参阅访问控制列表页面了解更多信息。

命令提示

有关命令的有用信息。供客户/代理使用。

请查看命令提示页面以获取更多信息。

主要规格

这是一个由命令的关键规范组成的数组。数组中的每个元素都是一个映射，描述了在命令参数中定位键的方法。

欲了解更多信息，请查看关键规格页面。

子命令

这是一个包含所有命令子命令（如果有）的数组。一些 Redis 命令有子命令（例如，CONFIGREWRITE的子命令）。数组中的每个元素代表一个子命令，并遵循与COMMAND的回复相同的规范。

返回值

数组回复：命令详细信息的嵌套列表。

数组中的命令顺序是随机的。

例子

以下是GET命令的COMMAND输出：

1)  1) "get"
    2) (integer) 2
    3) 1) readonly
       2) fast
    4) (integer) 1
    5) (integer) 1
    6) (integer) 1
    7) 1) @read
       2) @string
       3) @fast
    8) (empty array)
    9) 1) 1) "flags"
          2) 1) read
          3) "begin_search"
          4) 1) "type"
             2) "index"
             3) "spec"
             4) 1) "index"
                2) (integer) 1
          5) "find_keys"
          6) 1) "type"
             2) "range"
             3) "spec"
             4) 1) "lastkey"
                2) (integer) 0
                3) "keystep"
                4) (integer) 1
                5) "limit"
                6) (integer) 0
   10) (empty array)
...

COMMAND COUNT

自 2.8.13 起可用。

时间复杂度： O(1)

返回此 Redis 服务器中总命令数的整数回复。

返回值
整数回复： COMMAND返回的命令数

例子

redis> COMMAND COUNT
(integer) 240
redis> 

COMMAND DOCS [command-name [command-name ...]]

自 7.0.0 起可用。

时间复杂度： O(N) 其中 N 是要查找的命令数

返回有关命令的文档信息。

默认情况下，回复包括服务器的所有命令。您可以使用可选的命令名称参数来指定一个或多个命令的名称。

回复包括每个返回命令的映射。映射回复中可能包含以下键：

• 摘要：简短的命令描述。
• 因为：添加命令的 Redis 版本。
• group：命令所属的功能组。可能的值为：
  • 位图
  • 簇
  • 联系
  • 通用的
  • 地理
  • 哈希
  • 超日志
  • 列表
  • 模块
  • 发布订阅
  • 脚本
  • 哨兵
  • 服务器
  • 放
  • 排序集
  • 溪流
  • 细绳
  • 交易
  • 复杂性：关于命令时间复杂度的简短说明。
• doc-flags：文档标志数组。可能的值为：
  • 已弃用：该命令已弃用。
  • syscmd：不打算由用户调用的系统命令。
• deprecated-since：弃用该命令的 Redis 版本。
• 替换为：已弃用命令的替代方法。
• history：一组历史记录，描述命令的行为或参数的变化。每个条目本身就是一个数组，由两个元素组成：
  • 该条目适用的 Redis 版本。
  • 更改的描述。
• arguments：描述命令参数的映射数组。有关详细信息，请参阅Redis 命令参数页面。

返回值

Array reply：如上所述的作为扁平数组的地图。

例子

redis> COMMAND DOCS SET
1) "set"
2)  1) "summary"
    2) "Set the string value of a key"
    3) "since"
    4) "1.0.0"
    5) "group"
    6) "string"
    7) "complexity"
    8) "O(1)"
    9) "history"
   10) 1) 1) "2.6.12"
          2) "Added the `EX`, `PX`, `NX` and `XX` options."
       2) 1) "6.0.0"
          2) "Added the `KEEPTTL` option."
       3) 1) "6.2.0"
          2) "Added the `GET`, `EXAT` and `PXAT` option."
       4) 1) "7.0.0"
          2) "Allowed the `NX` and `GET` options to be used together."
   11) "arguments"
   12) 1) 1) "name"
          2) "key"
          3) "type"
          4) "key"
          5) "key_spec_index"
          6) (integer) 0
       2) 1) "name"
          2) "value"
          3) "type"
          4) "string"
       3) 1) "name"
          2) "expiration"
          3) "type"
          4) "oneof"
          5) "flags"
          6) 1) "optional"
          7) "arguments"
          8) 1) 1) "name"
                2) "seconds"
                3) "type"
                4) "integer"
                5) "token"
                6) "EX"
                7) "since"
                8) "2.6.12"
             2) 1) "name"
                2) "milliseconds"
                3) "type"
                4) "integer"
                5) "token"
                6) "PX"
                7) "since"
                8) "2.6.12"
             3) 1) "name"
                2) "unix-time-seconds"
                3) "type"
                4) "unix-time"
                5) "token"
                6) "EXAT"
                7) "since"
                8) "6.2.0"
             4) 1) "name"
                2) "unix-time-milliseconds"
                3) "type"
                4) "unix-time"
                5) "token"
                6) "PXAT"
                7) "since"
                8) "6.2.0"
             5) 1) "name"
                2) "keepttl"
                3) "type"
                4) "pure-token"
                5) "token"
                6) "KEEPTTL"
                7) "since"
                8) "6.0.0"
       4)  1) "name"
           2) "condition"
           3) "type"
           4) "oneof"
           5) "since"
           6) "2.6.12"
           7) "flags"
           8) 1) "optional"
           9) "arguments"
          10) 1) 1) "name"
                 2) "nx"
                 3) "type"
                 4) "pure-token"
                 5) "token"
                 6) "NX"
              2) 1) "name"
                 2) "xx"
                 3) "type"
                 4) "pure-token"
                 5) "token"
                 6) "XX"
       5)  1) "name"
           2) "get"
           3) "type"
           4) "pure-token"
           5) "token"
           6) "GET"
           7) "since"
           8) "6.2.0"
           9) "flags"
          10) 1) "optional"

COMMAND GETKEYS

自 2.8.13 起可用。

时间复杂度： O(N) 其中 N 是命令的参数数量

从完整的 Redis 命令返回键的数组回复。

COMMAND GETKEYS是一个帮助命令，可让您从完整的 Redis 命令中找到密钥。

COMMAND提供有关如何查找每个命令的键名的信息（请参阅firstkey、键规范和movablekeys），但在某些情况下，无法找到某些命令的键，然后必须解析整个命令以发现一些/所有键名. 您可以使用COMMAND GETKEYS或COMMAND GETKEYSANDFLAGS直接从 Redis 解析命令的方式中发现键名。

返回值

数组回复：命令中的键列表。

例子

redis> COMMAND GETKEYS MSET a b c d e f
1) "a"
2) "c"
3) "e"
redis> COMMAND GETKEYS EVAL "not consulted" 3 key1 key2 key3 arg1 arg2 arg3 argN
1) "key1"
2) "key2"
3) "key3"
redis> COMMAND GETKEYS SORT mylist ALPHA STORE outlist
1) "mylist"
2) "outlist"
redis> 

COMMAND GETKEYSANDFLAGS

自 7.0.0 起可用。

时间复杂度： O(N) 其中 N 是命令的参数数量

返回来自完整 Redis 命令的键的数组回复及其使用标志。

COMMAND GETKEYSANDFLAGS是一个帮助命令，可让您从完整的 Redis 命令中找到键以及指示每个键的用途的标志。

COMMAND提供有关如何查找每个命令的键名的信息（请参阅firstkey、键规范和movablekeys），但在某些情况下，无法找到某些命令的键，然后必须解析整个命令以发现一些/所有键名. 您可以使用COMMAND GETKEYS或COMMAND GETKEYSANDFLAGS直接从 Redis 解析命令的方式中发现键名。

有关密钥标志含义的信息，请参阅密钥规范。

返回值

数组回复：命令中的键列表。数组的每个元素都是一个数组，其中第一个条目包含键名，第二个条目包含标志。

例子

redis> COMMAND GETKEYS MSET a b c d e f
1) "a"
2) "c"
3) "e"
redis> COMMAND GETKEYS EVAL "not consulted" 3 key1 key2 key3 arg1 arg2 arg3 argN
1) "key1"
2) "key2"
3) "key3"
redis> COMMAND GETKEYSANDFLAGS LMOST mylist1 mylist2 left left
ERR ERR Invalid command specified
redis> 

COMMAND INFO [command-name [command-name ...]]

自 2.8.13 起可用。

时间复杂度： O(N) 其中 N 是要查找的命令数

返回有关多个 Redis 命令的详细信息的数组回复。

与COMMAND相同的结果格式，但您可以指定返回哪些命令。

如果您请求有关不存在命令的详细信息，则它们的返回位置将为 nil。

返回值
数组回复：命令详细信息的嵌套列表。

例子

redis> COMMAND INFO get set eval
1)  1) "get"
    2) (integer) 2
    3) 1) "readonly"
       2) "fast"
    4) (integer) 1
    5) (integer) 1
    6) (integer) 1
    7) 1) "@read"
       2) "@string"
       3) "@fast"
    8) (empty list or set)
    9) 1) 1) "flags"
          2) 1) "RO"
             2) "access"
          3) "begin_search"
          4) 1) "type"
             2) "index"
             3) "spec"
             4) 1) "index"
                2) (integer) 1
          5) "find_keys"
          6) 1) "type"
             2) "range"
             3) "spec"
             4) 1) "lastkey"
                2) (integer) 0
                3) "keystep"
                4) (integer) 1
                5) "limit"
                6) (integer) 0
   10) (empty list or set)
2)  1) "set"
    2) (integer) -3
    3) 1) "write"
       2) "denyoom"
       3) "movablekeys"
    4) (integer) 1
    5) (integer) 1
    6) (integer) 1
    7) 1) "@write"
       2) "@string"
       3) "@slow"
    8) (empty list or set)
    9) 1) 1) "notes"
          2) "RW and ACCESS due to the optional `GET` argument"
          3) "flags"
          4) 1) "RW"
             2) "access"
             3) "update"
             4) "variable_flags"
          5) "begin_search"
          6) 1) "type"
             2) "index"
             3) "spec"
             4) 1) "index"
                2) (integer) 1
          7) "find_keys"
          8) 1) "type"
             2) "range"
             3) "spec"
             4) 1) "lastkey"
                2) (integer) 0
                3) "keystep"
                4) (integer) 1
                5) "limit"
                6) (integer) 0
   10) (empty list or set)
3)  1) "eval"
    2) (integer) -3
    3) 1) "noscript"
       2) "stale"
       3) "skip_monitor"
       4) "may_replicate"
       5) "no_mandatory_keys"
       6) "movablekeys"
    4) (integer) 0
    5) (integer) 0
    6) (integer) 0
    7) 1) "@slow"
       2) "@scripting"
    8) (empty list or set)
    9) 1) 1) "notes"
          2) "We cannot tell how the keys will be used so we assume the worst, RW and UPDATE"
          3) "flags"
          4) 1) "RW"
             2) "access"
             3) "update"
          5) "begin_search"
          6) 1) "type"
             2) "index"
             3) "spec"
             4) 1) "index"
                2) (integer) 2
          7) "find_keys"
          8) 1) "type"
             2) "keynum"
             3) "spec"
             4) 1) "keynumidx"
                2) (integer) 0
                3) "firstkey"
                4) (integer) 1
                5) "keystep"
                6) (integer) 1
   10) (empty list or set)
redis> COMMAND INFO foo evalsha config bar
1) (nil)
2)  1) "evalsha"
    2) (integer) -3
    3) 1) "noscript"
       2) "stale"
       3) "skip_monitor"
       4) "may_replicate"
       5) "no_mandatory_keys"
       6) "movablekeys"
    4) (integer) 0
    5) (integer) 0
    6) (integer) 0
    7) 1) "@slow"
       2) "@scripting"
    8) (empty list or set)
    9) 1) 1) "flags"
          2) 1) "RW"
             2) "access"
             3) "update"
          3) "begin_search"
          4) 1) "type"
             2) "index"
             3) "spec"
             4) 1) "index"
                2) (integer) 2
          5) "find_keys"
          6) 1) "type"
             2) "keynum"
             3) "spec"
             4) 1) "keynumidx"
                2) (integer) 0
                3) "firstkey"
                4) (integer) 1
                5) "keystep"
                6) (integer) 1
   10) (empty list or set)
3)  1) "config"
    2) (integer) -2
    3) (empty list or set)
    4) (integer) 0
    5) (integer) 0
    6) (integer) 0
    7) 1) "@slow"
    8) (empty list or set)
    9) (empty list or set)
   10) 1)  1) "config|get"
           2) (integer) -3
           3) 1) "admin"
              2) "noscript"
              3) "loading"
              4) "stale"
           4) (integer) 0
           5) (integer) 0
           6) (integer) 0
           7) 1) "@admin"
              2) "@slow"
              3) "@dangerous"
           8) (empty list or set)
           9) (empty list or set)
          10) (empty list or set)
       2)  1) "config|rewrite"
           2) (integer) 2
           3) 1) "admin"
              2) "noscript"
              3) "loading"
              4) "stale"
           4) (integer) 0
           5) (integer) 0
           6) (integer) 0
           7) 1) "@admin"
              2) "@slow"
              3) "@dangerous"
           8) (empty list or set)
           9) (empty list or set)
          10) (empty list or set)
       3)  1) "config|help"
           2) (integer) 2
           3) 1) "loading"
              2) "stale"
           4) (integer) 0
           5) (integer) 0
           6) (integer) 0
           7) 1) "@slow"
           8) (empty list or set)
           9) (empty list or set)
          10) (empty list or set)
       4)  1) "config|resetstat"
           2) (integer) 2
           3) 1) "admin"
              2) "noscript"
              3) "loading"
              4) "stale"
           4) (integer) 0
           5) (integer) 0
           6) (integer) 0
           7) 1) "@admin"
              2) "@slow"
              3) "@dangerous"
           8) (empty list or set)
           9) (empty list or set)
          10) (empty list or set)
       5)  1) "config|set"
           2) (integer) -4
           3) 1) "admin"
              2) "noscript"
              3) "loading"
              4) "stale"
           4) (integer) 0
           5) (integer) 0
           6) (integer) 0
           7) 1) "@admin"
              2) "@slow"
              3) "@dangerous"
           8) 1) "request_policy:all_nodes"
              2) "response_policy:all_succeeded"
           9) (empty list or set)
          10) (empty list or set)
4) (nil)
redis> 

历史

• Redis 版本 >= 7.0.0：允许在不带参数的情况下调用以获取所有命令的信息。

COMMAND LIST [FILTERBY MODULE module-name|ACLCAT category|PATTERN pattern]

自 7.0.0 起可用。

时间复杂度： O(N) 其中 N 是 Redis 命令的总数

返回服务器命令名称的数组。

您可以使用可选的FILTERBY修饰符来应用以下过滤器之一：

• MODULE module-name：获取属于module-name指定的模块的命令。
• ACLCAT 类别：获取category指定的ACL 类别中的命令。
• PATTERN pattern ：获取与给定 glob-like pattern匹配的命令。

返回值

数组回复：命令名称列表。

CONFIG GET parameter [parameter ...]

从 2.0.0 开始可用。

时间复杂度：当 N 是提供的配置参数的数量时 O(N)

CONFIG GET命令用于读取正在运行的 Redis 服务器的配置参数。Redis 2.4 并非支持所有配置参数，而 Redis 2.6 可以使用此命令读取服务器的整个配置。

用于在运行时更改配置的对称命令是CONFIG SET.

CONFIG GET接受多个参数，它们是 glob 样式的模式。与任何模式匹配的任何配置参数都将报告为键值对列表。例子：

redis> config get *max-*-entries* maxmemory
 1) "maxmemory"
 2) "0"
 3) "hash-max-listpack-entries"
 4) "512"
 5) "hash-max-ziplist-entries"
 6) "512"
 7) "set-max-intset-entries"
 8) "512"
 9) "zset-max-listpack-entries"
10) "128"
11) "zset-max-ziplist-entries"
12) "128"

CONFIG GET *您可以通过键入打开的redis-cli提示来获取所有受支持的配置参数的列表 。

所有支持的参数与redis.conf文件中使用的等效配置参数含义相同：

请注意，您应该查看与您正在使用的版本相关的 redis.conf 文件，因为配置选项可能会在版本之间发生变化。上面的链接是最新的开发版本。

返回值

该命令的返回类型是一个数组回复。

历史

• Redis 版本 >= 7.0.0：增加了一次调用传递多个模式参数的能力

CONFIG RESETSTAT

从 2.0.0 开始可用。

时间复杂度： O(1)

使用INFO命令重置 Redis 报告的统计信息。

这些是重置的计数器：

• 键空间命中
• 键空间未命中
• 处理的命令数
• 接收的连接数
• 过期密钥的数量
• 被拒绝的连接数
• 最新分叉(2)时间
• aof_delayed_fsync柜台_

返回值

简单的字符串回复：总是OK。

CONFIG REWRITE

自 2.8.0 起可用。

时间复杂度： O(1)

CONFIG REWRITE命令重写服务器启动时使用的文件redis.conf，应用所需的最小更改以使其反映服务器当前使用的配置，由于使用了CONFIG SET命令，这可能与原始配置不同。

重写以非常保守的方式执行：

• 尽可能保留原始redis.conf的注释和整体结构。
• 如果旧的 redis.conf 文件中已经存在一个选项，它将在相同的位置（行号）重写。
• 如果选项不存在，但设置为其默认值，则重写过程不会添加它。
• 如果选项不存在，但设置为非默认值，则将其附加在文件末尾。
• 未使用的行被空白。例如，如果您曾经有多个save指令，但当前配置较少或没有，因为您禁用了 RDB 持久性，所有行都将空白。

如果原始配置文件由于某种原因不再存在，CONFIG REWRITE 还能够从头开始重写配置文件。但是，如果服务器在没有配置文件的情况下启动，则 CONFIG REWRITE 只会返回一个错误。

原子重写过程

为了确保 redis.conf 文件始终保持一致，也就是说，在发生错误或崩溃时，您总是以旧文件或新文件结束，重写是通过write(2)具有足够内容的单个调用执行的，至少和旧文件一样大。有时会以注释的形式添加额外的填充以确保生成的文件足够大，然后文件会被截断以删除最后的填充。

返回值

简单字符串回复：OK正确重写配置时。否则返回错误。

CONFIG SET parameter value [parameter value ...]

从 2.0.0 开始可用。

时间复杂度：当 N 是提供的配置参数的数量时 O(N)

CONFIG SET命令用于在运行时重新配置服务器，而无需重新启动 Redis 。您可以使用此命令更改这两个微不足道的参数或从一个持久性选项切换到另一个持久性选项。

CONFIG SET支持的配置参数列表可以通过CONFIG GET *命令获取，即对称命令用于获取正在运行的 Redis 实例的配置信息。

使用CONFIG SET设置的所有配置参数都会立即被 Redis 加载，并从执行的下一条命令开始生效。

所有支持的参数与redis.conf文件中使用的等效配置参数的含义相同。

请注意，您应该查看与您正在使用的版本相关的 redis.conf 文件，因为配置选项可能会在版本之间发生变化。上面的链接是最新的开发版本。

可以使用CONFIG SET命令将持久性从 RDB 快照切换到仅附加文件（反之亦然）。有关如何执行此操作的更多信息，请查看持久性页面。

一般来说，您应该知道的是，将appendonly参数设置为 yes将启动后台进程以保存初始仅附加文件（从内存数据集中获得），并将所有后续命令附加到仅附加文件上，因此获得与自启动以来开启 AOF 的 Redis 服务器完全相同的效果。

如果需要，您可以使用 RDB 快照同时启用 AOF，这两个选项并不相互排斥。

返回值

简单字符串回复：OK正确设置配置时。否则返回错误。

历史

Redis 版本 >= 7.0.0：增加了一次调用设置多个参数的功能。

DBSIZE

从 1.0.0 开始可用。

时间复杂度： O(1)

返回当前选定数据库中的键数。

返回值

整数回复

FAILOVER [TO host port [FORCE]] [ABORT] [TIMEOUT milliseconds]

从 6.2.0 开始可用。

时间复杂度： O(1)

此命令将在当前连接到的主服务器和它的一个副本之间启动协调故障转移。故障转移不是同步的，而是后台任务将处理协调故障转移。它旨在限制故障转移期间集群的数据丢失和不可用。该命令类似于非集群 Redis的CLUSTER FAILOVER命令，类似于 sentinel 提供的故障转移支持。

默认故障转移流程的具体细节如下：

1. master 将在内部启动 a CLIENT PAUSE WRITE，这将暂停传入的写入并防止在复制流中积累新数据。
2. master 将监视它的副本，等待一个副本表明它已经完全消耗了复制流。如果master有多个replica，它只会等待第一个replica赶上来。
3. 然后主服务器将自己降级为副本。这样做是为了防止任何双主场景。注意：master 不会丢弃其数据，因此如果副本在下一步拒绝故障转移请求，它将能够回滚。
4. 前一个master会向目标replica发送一个特殊的PSYNC请求PSYNC FAILOVER，指示目标replica成为master。
5. 一旦前一个主机收到确认PSYNC FAILOVER被接受，它将取消暂停其客户端。如果 PSYNC 请求被拒绝，master 将中止故障转移并恢复正常。

master_failover_statein字段INFO replication可用于跟踪故障转移的当前状态，具有以下值：

• no-failover：没有正在进行的协调故障转移。
• waiting-for-sync: master 正在等待副本赶上它的复制偏移量。
• failover-in-progress：master 已降级，并试图将所有权移交给目标副本。

如果之前的 master 附加了额外的副本，它们将继续从它作为链式副本进行复制。您需要在这些副本上手动执行REPLICAOF才能直接从新的主副本开始复制。

可选参数

存在以下可选参数来修改故障转移流的行为：

• TIMEOUT 毫秒- 此选项允许指定主机waiting-for-sync在中止故障转移尝试和回滚之前在状态中等待的最长时间。这是为了设置 Redis 集群可能遇到的写入中断的上限。故障转移通常在不到一秒的时间内发生，但如果存在大量写入流量或副本已经落后于使用复制流，则可能需要更长时间。如果未指定此值，则可以认为超时是“无限的”。
• TO HOST PORT——此选项允许通过其主机和端口指定特定副本以进行故障转移。master 将专门等待这个副本赶上它的复制偏移量，然后故障转移到它。
• FORCE-- 如果设置了TIMEOUT和TO选项，也可以使用强制标志来指定一旦超时过去，主服务器应该故障转移到目标副本而不是回滚。这可用于在不丢失数据但限制写入中断的情况下尽最大努力尝试故障转移。

PSYNC FAILOVER注意：如果请求被目标副本拒绝，主服务器将始终回滚。

故障转移中止

故障转移命令旨在防止数据丢失和损坏，但可能会遇到一些无法自动修复的情况，并且可能会卡住。为此，该FAILOVER ABORT命令存在，它将中止正在进行的故障转移并将主服务器恢复到其正常状态。该命令在状态下发出没有副作用，waiting-for-sync但可以在状态下引入多主场景failover-in-progress。如果遇到多master的场景，你需要手动识别哪个master拥有最新的数据，并指定它为master，拥有其他的replica。

注意：在进行故障转移时会禁用REPLICAOF，这是为了防止与可能导致数据丢失的故障转移发生意外交互。

返回值

简单字符串回复：OK如果命令被接受并且协调的故障转移正在进行中。如果操作无法执行，则会出错。

FLUSHALL [ASYNC|SYNC]

从 1.0.0 开始可用。

时间复杂度： O(N) 其中 N 是所有数据库中键的总数

删除所有现有数据库的所有键，而不仅仅是当前选择的一个。这个命令永远不会失败。

默认情况下，FLUSHALL将同步刷新所有数据库。从 Redis 6.2 开始，将lazyfree-lazy-user-flush配置指令设置为“yes”会将默认刷新模式更改为异步。

可以使用以下修饰符之一来明确规定冲洗模式：

• ASYNC: 异步刷新数据库
• SYNC: 同步刷新数据库

注意：异步FLUSHALL命令仅删除调用命令时存在的键。在异步刷新期间创建的密钥将不受影响。

返回值

简单的字符串回复

历史

• Redis 版本 >= 4.0.0：添加了 ASYNC 刷新模式修饰符。
• Redis 版本 >= 6.2.0：添加了 SYNC 刷新模式修饰符和 lazyfree-lazy-user-flush 配​​置指令。

FLUSHDB [ASYNC|SYNC]

从 1.0.0 开始可用。

时间复杂度： O(N) 其中 N 是所选数据库中的键数

删除当前选定数据库的所有键。这个命令永远不会失败。

默认情况下，FLUSHDB将同步刷新数据库中的所有键。从 Redis 6.2 开始，将lazyfree-lazy-user-flush配置指令设置为“yes”会将默认刷新模式更改为异步。

可以使用以下修饰符之一来明确规定冲洗模式：

• ASYNC: 异步刷新数据库
• SYNC: 同步刷新数据库

注意：异步FLUSHDB命令仅删除调用命令时存在的键。在异步刷新期间创建的密钥将不受影响。

返回值

简单的字符串回复

历史

• Redis 版本 >= 4.0.0：添加了 ASYNC 刷新模式修饰符。
• Redis 版本 >= 6.2.0：添加了 SYNC 刷新模式修饰符和 lazyfree-lazy-user-flush 配​​置指令。

INFO [section [section ...]]

从 1.0.0 开始可用。

时间复杂度： O(1)

INFO命令以计算机易于解析且人类易于阅读的格式返回有关服务器的信息和统计信息。

可选参数可用于选择特定的信息部分：

• server: Redis 服务器的一般信息
• clients：客户端连接部分
• memory: 内存消耗相关信息
• persistence：RDB和AOF相关信息
• stats: 一般统计
• replication：主/副本复制信息
• cpu：CPU消耗统计
• commandstats: Redis 命令统计
• latencystats: Redis 命令延迟百分位分布统计
• cluster: Redis 集群部分
• modules: 模块部分
• keyspace: 数据库相关统计
• modules: 模块相关部分
• errorstats: Redis 错误统计

它还可以采用以下值：

• all：返回所有部分（不包括模块生成的部分）
• default：仅返回默认的部分集
• everything: 包括all和modules

如果未提供参数，default则假定该选项。

返回值

批量字符串回复：作为文本行的集合。

行可以包含部分名称（以 # 字符开头）或属性。所有的属性都是由field:value终止的形式\r\n。

redis> INFO
# Server
redis_version:6.9.241
redis_git_sha1:00000000
redis_git_dirty:0
redis_build_id:252898f924845c95
redis_mode:standalone
os:Linux 5.4.0-1030-aws x86_64
arch_bits:64
multiplexing_api:epoll
atomicvar_api:c11-builtin
gcc_version:9.3.0
process_id:3288478
process_supervised:no
run_id:6350d0f78d975c16bbe578a35fb9cd46330d4b85
tcp_port:6379
server_time_usec:1647574931919389
uptime_in_seconds:1517494
uptime_in_days:17
hz:10
configured_hz:10
lru_clock:3407763
executable:/usr/local/bin/redis-server
config_file:/etc/redis/redis.conf
io_threads_active:0

# Clients
connected_clients:2
cluster_connections:0
maxclients:10000
client_recent_max_input_buffer:20480
client_recent_max_output_buffer:0
blocked_clients:0
tracking_clients:0
clients_in_timeout_table:0

# Memory
used_memory:199963512
used_memory_human:190.70M
used_memory_rss:228495360
used_memory_rss_human:217.91M
used_memory_peak:200757376
used_memory_peak_human:191.46M
used_memory_peak_perc:99.60%
used_memory_overhead:58366584
used_memory_startup:825576
used_memory_dataset:141596928
used_memory_dataset_perc:71.10%
allocator_allocated:200095424
allocator_active:220250112
allocator_resident:227110912
total_system_memory:16596955136
total_system_memory_human:15.46G
used_memory_lua:37888
used_memory_vm_eval:37888
used_memory_lua_human:37.00K
used_memory_scripts_eval:0
number_of_cached_scripts:0
number_of_functions:0
number_of_libraries:0
used_memory_vm_functions:37888
used_memory_vm_total:75776
used_memory_vm_total_human:74.00K
used_memory_functions:184
used_memory_scripts:184
used_memory_scripts_human:184B
maxmemory:200000000
maxmemory_human:190.73M
maxmemory_policy:allkeys-lru
allocator_frag_ratio:1.10
allocator_frag_bytes:20154688
allocator_rss_ratio:1.03
allocator_rss_bytes:6860800
rss_overhead_ratio:1.01
rss_overhead_bytes:1384448
mem_fragmentation_ratio:1.14
mem_fragmentation_bytes:28533696
mem_not_counted_for_evict:0
mem_replication_backlog:0
mem_total_replication_buffers:0
mem_clients_slaves:0
mem_clients_normal:45568
mem_cluster_links:0
mem_aof_buffer:0
mem_allocator:jemalloc-5.2.1
active_defrag_running:0
lazyfree_pending_objects:0
lazyfreed_objects:0

# Persistence
loading:0
async_loading:0
current_cow_peak:0
current_cow_size:0
current_cow_size_age:0
current_fork_perc:0.00
current_save_keys_processed:0
current_save_keys_total:0
rdb_changes_since_last_save:258
rdb_bgsave_in_progress:0
rdb_last_save_time:1647574876
rdb_last_bgsave_status:ok
rdb_last_bgsave_time_sec:2
rdb_current_bgsave_time_sec:-1
rdb_saves:5007
rdb_last_cow_size:1757184
rdb_last_load_keys_expired:0
rdb_last_load_keys_loaded:1058966
aof_enabled:0
aof_rewrite_in_progress:0
aof_rewrite_scheduled:0
aof_last_rewrite_time_sec:-1
aof_current_rewrite_time_sec:-1
aof_last_bgrewrite_status:ok
aof_rewrites:0
aof_last_write_status:ok
aof_last_cow_size:0
module_fork_in_progress:0
module_fork_last_cow_size:0

# Stats
total_connections_received:120387
total_commands_processed:14959367
instantaneous_ops_per_sec:19
total_net_input_bytes:1236584705
total_net_output_bytes:196786584
instantaneous_input_kbps:1.58
instantaneous_output_kbps:0.22
rejected_connections:0
sync_full:0
sync_partial_ok:0
sync_partial_err:0
expired_keys:53481
expired_stale_perc:0.01
expired_time_cap_reached_count:0
expire_cycle_cpu_milliseconds:103009
evicted_keys:1124222
evicted_clients:0
total_eviction_exceeded_time:7480
current_eviction_exceeded_time:0
keyspace_hits:3535560
keyspace_misses:1610834
pubsub_channels:0
pubsub_patterns:0
latest_fork_usec:3992
total_forks:5007
migrate_cached_sockets:0
slave_expires_tracked_keys:0
active_defrag_hits:0
active_defrag_misses:0
active_defrag_key_hits:0
active_defrag_key_misses:0
total_active_defrag_time:0
current_active_defrag_time:0
tracking_total_keys:0
tracking_total_items:0
tracking_total_prefixes:0
unexpected_error_replies:0
total_error_replies:7470
dump_payload_sanitizations:0
total_reads_processed:14951877
total_writes_processed:14951858
io_threaded_reads_processed:0
io_threaded_writes_processed:0
reply_buffer_shrinks:7045
reply_buffer_expands:7147

# Replication
role:master
connected_slaves:0
master_failover_state:no-failover
master_replid:d46a6bcecddc046081f9c46cab378f3c438aff96
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

# CPU
used_cpu_sys:1275.303523
used_cpu_user:14413.242950
used_cpu_sys_children:606.426147
used_cpu_user_children:12205.097831
used_cpu_sys_main_thread:1274.579194
used_cpu_user_main_thread:14411.899176

# Modules

# Errorstats
errorstat_ERR:count=5589
errorstat_LOADING:count=1
errorstat_WRONGTYPE:count=1880

# Cluster
cluster_enabled:0

# Keyspace
db0:keys=1016645,expires=1494,avg_ttl=152740966966182
redis> 

笔记

请注意，根据 Redis 的版​​本，某些字段已被添加或删除。因此，一个健壮的客户端应用程序应该通过跳过未知属性来解析这个命令的结果，并优雅地处理丢失的字段。

这是 Redis >= 2.4 的字段说明。

以下是服务器部分中所有字段的含义：

• redis_version: Redis 服务器的版本
• redis_git_sha1：Git SHA1
• redis_git_dirty: Git 脏标志
• redis_build_id：构建ID
• redis_mode：服务器的模式（“独立”、“哨兵”或“集群”）
• os: 托管 Redis 服务器的操作系统
• arch_bits：架构（32 或 64 位）
• multiplexing_api: Redis 使用的事件循环机制
• atomicvar_api: Redis 使用的 Atomicvar API
• gcc_version: 用于编译 Redis 服务器的 GCC 编译器版本
• process_id: 服务器进程的PID
• process_supervised：受监督的系统（“upstart”、“systemd”、“unknown”或“no”）
• run_id: 标识 Redis 服务器的随机值（由 Sentinel 和 Cluster 使用）
• tcp_port: TCP/IP 监听端口
• server_time_usec：基于纪元的系统时间，精度为微秒
• uptime_in_seconds: Redis 服务器启动后的秒数
• uptime_in_days：以天为单位表示的相同值
• hz：服务器当前频率设置
• configured_hz：服务器配置的频率设置
• lru_clock：时钟每分钟递增一次，用于 LRU 管理
• executable: 服务器可执行文件的路径
• config_file: 配置文件的路径
• io_threads_active: 指示 I/O 线程是否处于活动状态的标志
• shutdown_in_milliseconds：副本在完成关闭序列之前赶上复制的最长时间。该字段仅在关机期间出现。

以下是客户端部分中所有字段的含义：

• connected_clients: 客户端连接数（不包括来自副本的连接）
• cluster_connections：集群总线使用的套接字数量的近似值
• maxclients：maxclients配置指令的值。connected_clients这是 和之connected_slaves和 的上限cluster_connections。
• client_recent_max_input_buffer: 当前客户端连接中最大的输入缓冲区
• client_recent_max_output_buffer: 当前客户端连接中最大的输出缓冲区
• blocked_clients：等待阻塞调用的客户端数量（BLPOP、 BRPOP、BRPOPLPUSH、BLMOVE、BZPOPMIN、BZPOPMAX）
• tracking_clients：被跟踪的客户数量（CLIENT TRACKING）
• clients_in_timeout_table: 客户端超时表中的客户端数量

以下是内存部分中所有字段的含义：

• used_memory: Redis 使用其分配器分配的总字节数（标准libc、jemalloc或替代分配器，例如tcmalloc）
• used_memory_human：以前值的人类可读表示
• used_memory_rss：操作系统看到的 Redis 分配的字节数（也称为驻留集大小）。这是由工具报告的数字，例如top(1)和ps(1)
• used_memory_rss_human：以前值的人类可读表示
• used_memory_peak: Redis 消耗的峰值内存（以字节为单位）
• used_memory_peak_human：以前值的人类可读表示
• used_memory_peak_perc:used_memory_peak出来 的百分比used_memory
• used_memory_overhead：服务器分配用于管理其内部数据结构的所有开销的总和（以字节为单位）
• used_memory_startup: Redis 在启动时消耗的初始内存量（以字节为单位）
• used_memory_dataset：数据集的大小（以字节为单位）（used_memory_overhead减去used_memory）
• used_memory_dataset_percused_memory_dataset：超出净内存使用的百分比（used_memory减used_memory_startup）
• total_system_memory: Redis 主机拥有的内存总量
• total_system_memory_human：以前值的人类可读表示
• used_memory_lua: Lua 引擎使用的字节数
• used_memory_lua_human：以前值的人类可读表示
• used_memory_scripts: 缓存 Lua 脚本使用的字节数
• used_memory_scripts_human：以前值的人类可读表示
• maxmemory:maxmemory配置指令的值
• maxmemory_human：以前值的人类可读表示
• maxmemory_policy:maxmemory-policy配置指令的值
• mem_fragmentation_ratioused_memory_rss:和之间的比率used_memory。请注意，这不仅包括碎片，还包括其他进程开销（参见allocator_*指标），以及代码、共享库、堆栈等开销。
• mem_fragmentation_bytesused_memory_rss:和之间的差值used_memory。请注意，当总分片字节数较低（几兆字节）时，较高的比率（例如 1.5 及以上）并不表示存在问题。
• allocator_frag_ratio:allocator_active:和之间的比率allocator_allocated。这是真正的（外部）碎片度量（不是mem_fragmentation_ratio）。
• allocator_frag_bytesallocator_active和之间的增量allocator_allocated。请参阅关于mem_fragmentation_bytes.
• allocator_rss_ratioallocator_resident:和之间的比率allocator_active。这通常表明分配器可以并且可能很快将释放回操作系统的页面。
• allocator_rss_bytesallocator_resident:和之间的差值allocator_active
• rss_overhead_ratioused_memory_rss: (进程 RSS) 和之间的比率allocator_resident。这包括与分配器或堆无关的 RSS 开销。
• rss_overhead_bytes: used_memory_rss（进程 RSS）和allocator_resident
• allocator_allocated：从分配器分配的总字节数，包括内部碎片。通常与used_memory.
• allocator_active：分配器活动​​页面中的总字节数，这包括外部碎片。
• allocator_resident：分配器中的总字节数（RSS），这包括可以释放到操作系统的页面（通过MEMORY PURGE或只是等待）。
• mem_not_counted_for_evict: 使用的内存不计入键逐出。这基本上是瞬态副本和 AOF 缓冲区。
• mem_clients_slaves: 副本客户端使用的内存 - 从 Redis 7.0 开始，副本缓冲区与复制积压共享内存，因此当副本不触发内存使用量增加时，此字段可以显示 0。
• mem_clients_normal: 普通客户端使用的内存
• mem_cluster_links：启用集群模式时，链接到集群总线上的对等点所使用的内存。
• mem_aof_buffer: 用于 AOF 和 AOF 重写缓冲区的瞬态内存
• mem_replication_backlog：复制积压使用的内存
• mem_total_replication_buffers：复制缓冲区消耗的总内存 - 在 Redis 7.0 中添加。
• mem_allocator：内存分配器，在编译时选择。
• active_defrag_running：activedefrag启用时，这表明碎片整理当前是否处于活动状态，以及它打算使用的 CPU 百分比。
• lazyfree_pending_objects: 等待释放的对象数（由于调用UNLINK或FLUSHDB和FLUSHALL与ASYNC 选项）
• lazyfreed_objects: 已被延迟释放的对象数。

理想情况下，该used_memory_rss值应仅略高于 used_memory. 当使用 rss >> 时，较大的差异可能意味着存在（外部）内存碎片，可以通过检查 allocator_frag_ratio,来评估allocator_frag_bytes。当使用 >> rss 时，这意味着部分 Redis 内存已被操作系统交换掉：预计会有一些显着的延迟。

由于 Redis 无法控制其分配如何映射到内存页面，因此高used_memory_rss通常是内存使用量激增的结果。

当 Redis 释放内存时，内存会归还给分配器，分配器可能会将内存还给系统，也可能不会。used_memory操作系统报告的值和内存消耗之间可能存在差异。这可能是由于内存已被 Redis 使用和释放，但没有归还给系统。该 used_memory_peak值通常对检查这一点很有用。

可以通过参考MEMORY STATS命令和MEMORY DOCTOR获得有关服务器内存的其他内省信息。

以下是持久性部分中所有字段的含义：

• loading: 指示转储文件的加载是否正在进行的标志
• async_loading：当前在提供旧数据时异步加载复制数据集。这意味着repl-diskless-load启用并设置为swapdb。在 Redis 7.0 中添加。
• current_cow_peak：子叉子运行时写入时复制内存的峰值大小（以字节为单位）
• current_cow_size：子叉子运行时写入时复制内存的大小（以字节为单位）
• current_cow_size_age：值的年龄，以秒为单位current_cow_size。
• current_fork_perc：当前fork进程的进度百分比。对于 AOF 和 RDB 分叉，它是current_save_keys_processedout of的百分比current_save_keys_total。
• current_save_keys_processed：当前保存操作处理的键数
• current_save_keys_total：当前保存操作开始时的键数
• rdb_changes_since_last_save：自上次转储以来的更改次数
• rdb_bgsave_in_progress: 指示 RDB 保存正在进行的标志
• rdb_last_save_time: 最后一次成功 RDB 保存的基于 Epoch 的时间戳
• rdb_last_bgsave_status: 上次 RDB 保存操作的状态
• rdb_last_bgsave_time_sec：最后一次 RDB 保存操作的持续时间（以秒为单位）
• rdb_current_bgsave_time_sec: 正在进行的 RDB 保存操作的持续时间（如果有）
• rdb_last_cow_size: 上次 RDB 保存操作期间的写时复制内存大小（以字节为单位）
• rdb_last_load_keys_expired: 上次加载 RDB 期间删除的易失性键的数量。在 Redis 7.0 中添加。
• rdb_last_load_keys_loaded: 上次加载 RDB 期间加载的键数。在 Redis 7.0 中添加。
• aof_enabled：指示 AOF 日志记录已激活的标志
• aof_rewrite_in_progress: 指示 AOF 重写操作正在进行的标志
• aof_rewrite_scheduled：一旦正在进行的 RDB 保存完成，将安排指示 AOF 重写操作的标志。
• aof_last_rewrite_time_sec：最后一次 AOF 重写操作的持续时间（以秒为单位）
• aof_current_rewrite_time_sec：正在进行的 AOF 重写操作的持续时间（如果有）
• aof_last_bgrewrite_status: 上一次 AOF 重写操作的状态
• aof_last_write_status: 对 AOF 的最后一次写操作的状态
• aof_last_cow_size：最后一次 AOF 重写操作期间的写时复制内存的大小（以字节为单位）
• module_fork_in_progress：指示模块分叉正在进行的标志
• module_fork_last_cow_size：在最后一个模块分叉操作期间，写时复制内存的大小（以字节为单位）
• aof_rewrites: 自启动以来执行的 AOF 重写次数
• rdb_saves: 自启动以来执行的 RDB 快照数

rdb_changes_since_last_save指自上次调用SAVE或 BGSAVE以来在数据集中产生某种变化的操作数。

如果激活 AOF，将添加这些附加字段：

• aof_current_size: AOF 当前文件大小
• aof_base_size: 最近启动或重写时的 AOF 文件大小
• aof_pending_rewrite：一旦正在进行的 RDB 保存完成，将安排指示 AOF 重写操作的标志。
• aof_buffer_length: AOF 缓冲区的大小
• aof_rewrite_buffer_length：AOF 重写缓冲区的大小。请注意，此字段在 Redis 7.0 中已删除
• aof_pending_bio_fsync: 后台 I/O 队列中 fsync 挂起的作业数
• aof_delayed_fsync: 延迟 fsync 计数器

如果加载操作正在进行，将添加以下附加字段：

• loading_start_time：加载操作开始的基于纪元的时间戳
• loading_total_bytes：总文件大小
• loading_rdb_used_mem: 文件创建时已生成 RDB 文件的服务器的内存使用情况
• loading_loaded_bytes: 已加载的字节数
• loading_loaded_perc: 相同的值以百分比表示
• loading_eta_seconds: 以秒为单位的 ETA 加载完成

以下是stats部分中所有字段的含义：

• total_connections_received: 服务器接受的连接总数
• total_commands_processed: 服务器处理的命令总数
• instantaneous_ops_per_sec：每秒处理的命令数
• total_net_input_bytes: 从网络读取的总字节数
• total_net_output_bytes: 写入网络的总字节数
• instantaneous_input_kbps：每秒网络的读取速率，以 KB/sec 为单位
• instantaneous_output_kbps: 网络每秒的写入速率，以 KB/sec 为单位
• rejected_connections: 由于 maxclients限制而被拒绝的连接数
• sync_full：与副本完全重新同步的次数
• sync_partial_ok：接受的部分重新同步请求的数量
• sync_partial_err: 被拒绝的部分重新同步请求的数量
• expired_keys: 密钥过期事件总数
• expired_stale_perc: 密钥可能过期的百分比
• expired_time_cap_reached_count：活动到期周期提前停止的次数
• expire_cycle_cpu_milliseconds：在有效到期周期上花费的累计时间量
• evicted_keys: 由于maxmemory限制而被驱逐的键的数量
• evicted_clients：由于maxmemory-clients限制而被驱逐的客户数量。在 Redis 7.0 中添加。
• total_eviction_exceeded_time: 总时间used_memory大于maxmemory自服务器启动以来，以毫秒为单位
• current_eviction_exceeded_time: 自used_memory上次升到以上所经过的时间maxmemory，以毫秒为单位
• keyspace_hits: 在主字典中成功查找键的次数
• keyspace_misses: 在主字典中查找键失败的次数
• pubsub_channels：具有客户端订阅的全球发布/订阅频道数量
• pubsub_patterns：具有客户端订阅的全球发布/订阅模式数量
• latest_fork_usec: 最近一次分叉操作的持续时间，以微秒为单位
• total_forks: 自服务器启动以来的 fork 操作总数
• migrate_cached_sockets：为MIGRATE目的打开的套接字数量
• slave_expires_tracked_keys：为过期目的而跟踪的密钥数量（仅适用于可写副本）
• active_defrag_hits：由活跃的碎片整理过程执行的值重新分配的数量
• active_defrag_misses：活动碎片整理进程启动的中止值重新分配的数量
• active_defrag_key_hits：积极进行碎片整理的密钥数
• active_defrag_key_misses：活动碎片整理过程跳过的键数
• total_active_defrag_time: 内存碎片超过限制的总时间，以毫秒为单位
• current_active_defrag_time: 自上次内存碎片超过限制以来经过的时间，以毫秒为单位
• tracking_total_keys：服务器正在跟踪的密钥数
• tracking_total_items：正在跟踪的项目数，即每个键的客户数之和
• tracking_total_prefixes: 服务器前缀表中跟踪的前缀数（仅适用于广播模式）
• unexpected_error_replies：意外错误回复的数量，即来自 AOF 加载或复制的错误类型
• total_error_replies: 发出的错误回复总数，即被拒绝的命令（命令执行前的错误）和失败的命令（命令执行中的错误）的总和
• dump_payload_sanitizations：转储有效负载深度完整性验证的总数（请参阅sanitize-dump-payload配置）。
• total_reads_processed：处理的读取事件总数
• total_writes_processed: 处理的写事件总数
• io_threaded_reads_processed: 主线程和 I/O 线程处理的读取事件数
• io_threaded_writes_processed: 主线程和 I/O 线程处理的写事件数

以下是复制部分中所有字段的含义：

• role：如果实例是无人副本，则值为“master”，如果实例是某个主实例的副本，则值为“slave”。请注意，一个副本可以是另一个副本的主副本（链式复制）。
• master_failover_state：正在进行的故障转移的状态（如果有）。
• master_replid: Redis 服务器的复制 ID。
• master_replid2：辅助复制 ID，用于故障转移后的 PSYNC。
• master_repl_offset: 服务器当前的复制偏移量
• second_repl_offset: 接受复制 ID 的偏移量
• repl_backlog_active：指示复制积压工作的标志
• repl_backlog_size：复制积压缓冲区的总大小（以字节为单位）
• repl_backlog_first_byte_offset：复制积压缓冲区的主偏移量
• repl_backlog_histlen：复制积压缓冲区中数据的大小（以字节为单位）

如果实例是副本，则提供以下附加字段：

• master_host：主机的主机或IP地址
• master_port: 主监听 TCP 端口
• master_link_status：链接状态（上/下）
• master_last_io_seconds_ago: 自上次与 master 交互以来的秒数
• master_sync_in_progress：表示master正在同步到replica
• slave_read_repl_offset：副本实例的读取复制偏移量。
• slave_repl_offset：副本实例的复制偏移量
• slave_priority: 实例作为故障转移候选者的优先级
• slave_read_only: 指示副本是否为只读的标志
• replica_announced: 指示副本是否由 Sentinel 宣布的标志。

如果 SYNC 操作正在进行，则提供以下附加字段：

• master_sync_total_bytes：需要传输的字节总数。这可能是 0 当大小未知时（例如，当使用repl-diskless-sync配置指令时）
• master_sync_read_bytes：已传输的字节数
• master_sync_left_bytes：同步完成前剩余的字节数（为0时可能为负master_sync_total_bytes）
• master_sync_perc: 的百分比master_sync_read_bytes， master_sync_total_bytes或使用 loading_rdb_used_memwhen的近似值master_sync_total_bytes为 0
• master_sync_last_io_seconds_ago: SYNC 操作期间自上次传输 I/O 以来的秒数

如果 master 和 replica 之间的链接断开，则提供一个附加字段：

• master_link_down_since_seconds: 自链接断开以来的秒数

始终提供以下字段：

• connected_slaves: 连接的副本数

如果服务器配置了min-slaves-to-write（或从 Redis 5 开始带有min-replicas-to-write）指令，则提供一个附加字段：

• min_slaves_good_slaves：当前认为好的副本数

对于每个副本，添加以下行：

• slaveXXX: id、IP 地址、端口、状态、偏移量、滞后

以下是cpu部分中所有字段的含义：

• used_cpu_sys：Redis服务器消耗的系统CPU，是服务器进程所有线程（主线程和后台线程）消耗的系统CPU的总和
• used_cpu_user：Redis服务器消耗的用户CPU，是服务器进程所有线程（主线程和后台线程）消耗的用户CPU之和
• used_cpu_sys_children：后台进程消耗的系统CPU
• used_cpu_user_children：后台进程消耗的用户CPU
• used_cpu_sys_main_thread：Redis服务器主线程消耗的系统CPU
• used_cpu_user_main_thread：Redis服务器主线程消耗的用户CPU

commandstats部分提供基于命令类型的统计信息，包括到达命令执行（未拒绝）的调用次数、这些命令消耗的总 CPU 时间、每次命令执行消耗的平均 CPU、拒绝调用的次数（错误之前命令执行），以及失败的调用次数（命令执行中的错误）。

对于每种命令类型，添加以下行：

• cmdstat_XXX：calls=XXX,usec=XXX,usec_per_call=XXX,rejected_calls=XXX,failed_calls=XXX

delaystats部分根据命令类型提供延迟百分比分布统计信息。

默认情况下，导出的延迟百分位数是 p50、p99 和 p999。如果您需要更改导出的百分位数，请使用CONFIG SET latency-tracking-info-percentiles "50.0 99.0 99.9".

此部分需要启用扩展延迟监控功能（默认情况下已启用）。如果您需要启用它，请使用CONFIG SET latency-tracking yes.

对于每种命令类型，添加以下行：

• latency_percentiles_usec_XXX: p<percentile 1>=<percentile 1 value>,p<percentile 2>=<percentile 2 value>,...

errorstats部分可以根据回复错误前缀（“-”之后的第一个单词，直到第一个空格。示例：）来跟踪 Redis 中发生的不同错误ERR。

对于每种错误类型，添加以下行：

• errorstat_XXX：count=XXX

cluster部分目前仅包含一个唯一字段：

• cluster_enabled: 表示启用了 Redis 集群

如果模块提供，模块部分包含有关已加载模块的附加信息。本节中属性行的字段部分始终以模块名称为前缀。

键空间部分提供每个数据库主字典的统计信息。统计信息是密钥的数量，以及过期的密钥数量。

对于每个数据库，添加以下行：

• dbXXX：keys=XXX,expires=XXX

关于本手册页中使用的单词 slave 的说明：从 Redis 5 开始，如果不是为了向后兼容，Redis 项目不再使用单词 slave。不幸的是，在这个命令中，slave 这个词是协议的一部分，所以只有当这个 API 被自然弃用时，我们才能删除此类事件。

模块生成的部分：从 Redis 6 开始，模块可以将其信息注入INFO命令，即使all提供了参数，这些默认情况下也会被排除（它将包括已加载模块的列表，但不包括其生成的信息字段）。要获得这些，您必须使用modules参数或everything.,

历史

• Redis 版本 >= 7.0.0：添加了对采用多个部分参数的支持。

LASTSAVE

从 1.0.0 开始可用。

时间复杂度： O(1)

返回最后一次成功执行的数据库保存的 UNIX 时间。客户端可以检查BGSAVE命令是否成功读取LASTSAVE值，然后发出BGSAVE命令并每隔 N 秒定期检查LASTSAVE是否更改。

返回值

整数回复：UNIX 时间戳。

LATENCY DOCTOR

自 2.8.13 起可用。

时间复杂度： O(1)

LATENCY DOCTOR命令报告不同的延迟相关问题并就可能的补救措施提出建议。

该命令是延迟监控框架中最强大的分析工具，能够提供额外的统计数据，例如延迟峰值之间的平均周期、中值偏差以及对事件的人类可读分析。对于某些事件，例如fork，会提供附加信息，例如系统分叉进程的速率。

如果您正在寻求有关延迟相关问题的帮助，这是您应该在 Redis 邮件列表中发布的输出。

例子

127.0.0.1:6379> latency doctor

Dave, I have observed latency spikes in this Redis instance.
You don't mind talking about it, do you Dave?

1. command: 5 latency spikes (average 300ms, mean deviation 120ms,
    period 73.40 sec). Worst all time event 500ms.

I have a few advices for you:

- Your current Slow Log configuration only logs events that are
    slower than your configured latency monitor threshold. Please
    use 'CONFIG SET slowlog-log-slower-than 1000'.
- Check your Slow Log to understand what are the commands you are
    running which are too slow to execute. Please check
    http://redis.io/commands/slowlog for more information.
- Deleting, expiring or evicting (because of maxmemory policy)
    large objects is a blocking operation. If you have very large
    objects that are often deleted, expired, or evicted, try to
    fragment those objects into multiple smaller objects.

注意：医生有反复无常的心理行为，建议谨慎互动。

有关详细信息，请参阅延迟监控框架页面。

返回值

批量字符串回复

LATENCY GRAPH

自 2.8.13 起可用。

时间复杂度： O(1)

为指定的事件生成一个 ASCII 艺术风格的图表。

LATENCY GRAPHevent让您通过最先进的可视化直观地了解延迟趋势。它可以用于在求助于从LATENCY HISTORY或外部工具中解析原始数据等手段之前快速掌握情况。

有效值为event： * active-defrag-cycle * aof-fsync-always * aof-stat * aof-rewrite-diff-write * aof-rename * aof-write * aof-write-active-child * aof-write-alone * aof-write-pending-fsync * command * expire-cycle * eviction-cycle * eviction-del * fast-command * fork *rdb-unlink-temp-file

例子

127.0.0.1:6379> latency reset command
(integer) 0
127.0.0.1:6379> debug sleep .1
OK
127.0.0.1:6379> debug sleep .2
OK
127.0.0.1:6379> debug sleep .3
OK
127.0.0.1:6379> debug sleep .5
OK
127.0.0.1:6379> debug sleep .4
OK
127.0.0.1:6379> latency graph command
command - high 500 ms, low 101 ms (all time high 500 ms)
--------------------------------------------------------------------------------
   #_
  _||
 _|||
_||||

11186
542ss
sss

每个图表列下的垂直标签表示事件发生前的秒数、分钟数、小时数或天数。例如“15s”表示第一个图形事件发生在 15 秒前。

该图在 min-max 尺度上进行了归一化，因此零（下排中的下划线）是最小值，而上排中的 # 是最大值。

有关详细信息，请参阅延迟监控框架页面。

返回值

批量字符串回复

LATENCY HISTOGRAM [command [command ...]]

自 7.0.0 起可用。

时间复杂度： O(N)，其中 N 是要检索延迟信息的命令数。

LATENCY HISTOGRAM命令以直方图格式报告每个指定命令名称的累积延迟分布。如果未指定命令名称，则将回复所有包含延迟信息的命令。

每个报告的直方图都有以下字段：

• 命令名称。
• 该命令的总调用次数。
• 时间桶地图：
• 每个桶代表一个延迟范围。
• 每个存储桶覆盖前一个存储桶范围的两倍。
• 不打印空桶。
• 跟踪的延迟在 1 微秒到大约 1 秒之间。
• 超过 1 秒的所有内容都被视为 +Inf。
• 最大将有 log2(1000000000)=30 个桶。

此命令需要启用扩展延迟监控功能（默认情况下已启用）。如果您需要启用它，请使用CONFIG SET latency-tracking yes.

例子

127.0.0.1:6379> LATENCY HISTOGRAM set
1# "set" =>
   1# "calls" => (integer) 100000
   2# "histogram_usec" =>
      1# (integer) 1 => (integer) 99583
      2# (integer) 2 => (integer) 99852
      3# (integer) 4 => (integer) 99914
      4# (integer) 8 => (integer) 99940
      5# (integer) 16 => (integer) 99968
      6# (integer) 33 => (integer) 100000

返回值

地图回复：具体来说：

该命令返回一个映射，其中每个键是一个命令名称，每个值是一个带有总调用的映射，以及一个直方图时间桶的内部映射。在 RESP 2 回复中，地图被转换为数组。

LATENCY HISTORY event

自 2.8.13 起可用。

时间复杂度： O(1)

LATENCY HISTORYevent命令返回延迟峰值时间序列的原始数据。

这对于想要获取原始数据以执行监视、显示图形等的应用程序很有用。

该命令将为event.

有效值为event： * active-defrag-cycle * aof-fsync-always * aof-stat * aof-rewrite-diff-write * aof-rename * aof-write * aof-write-active-child * aof-write-alone * aof-write-pending-fsync * command * expire-cycle * eviction-cycle * eviction-del * fast-command * fork *rdb-unlink-temp-file

例子

127.0.0.1:6379> latency history command
1) 1) (integer) 1405067822
   2) (integer) 251
2) 1) (integer) 1405067941
   2) (integer) 1001

有关详细信息，请参阅延迟监控框架页面。

返回值

数组回复：具体来说：

该命令返回一个数组，其中每个元素都是一个两元素数组，表示事件的时间戳和延迟。

LATENCY LATEST

自 2.8.13 起可用。

时间复杂度： O(1)

LATENCY LATEST命令报告记录的最新延迟事件。

每个报告的事件都有以下字段：

• 事件名称。
• 事件的最新延迟峰值的 Unix 时间戳。
• 以毫秒为单位的最新事件延迟。
• 此事件的历史最大延迟。

“所有时间”是指自 Redis 实例启动以来的最大延迟，或者事件被重置的时间LATENCY RESET。

例子

127.0.0.1:6379> debug sleep 1
OK
(1.00s)
127.0.0.1:6379> debug sleep .25
OK
127.0.0.1:6379> latency latest
1) 1) "command"
   2) (integer) 1405067976
   3) (integer) 251
   4) (integer) 1001

有关详细信息，请参阅延迟监控框架页面。

返回值

数组回复：具体来说：

该命令返回一个数组，其中每个元素都是一个四元素数组，表示事件的名称、时间戳、最新和所有时间延迟测量。

LATENCY RESET [event [event ...]]

自 2.8.13 起可用。

时间复杂度： O(1)

LATENCY RESET命令重置所有或仅部分事件的延迟峰值时间序列。

当不带参数调用该命令时，它会重置所有事件，丢弃当前记录的延迟峰值事件，并重置最大事件时间寄存器。

通过提供event名称作为参数，可以仅重置特定事件。

有效值为event： * active-defrag-cycle * aof-fsync-always * aof-stat * aof-rewrite-diff-write * aof-rename * aof-write * aof-write-active-child * aof-write-alone * aof-write-pending-fsync * command * expire-cycle * eviction-cycle * eviction-del * fast-command * fork *rdb-unlink-temp-file

有关详细信息，请参阅延迟监控框架页面。

返回值

整数回复：重置的事件时间序列数。

LOLWUT [VERSION version]

从 5.0.0 开始可用。

LOLWUT 命令显示 Redis 版本：但是这样做的副作用是，它还创建了一个生成的计算机艺术，每个版本的 Redis 都不同。该命令是在 Redis 5 中引入的，并在此博客文章中宣布。

默认情况下，LOLWUT命令将显示与当前 Redis 版本对应的片段，但是可以使用以下形式显示特定版本：

LOLWUT VERSION 5 ... other optional arguments ...

当然上面的“5”是一个例子。每个 LOLWUT 版本都采用一组不同的参数来更改输出。鼓励用户使用它来发现输出如何更改添加更多数字参数。

LOLWUT 想要提醒人们，编程不仅仅是为了创造有用的东西而将一些代码放在一起。每个 LOLWUT 版本都应具有以下属性：

1. 它应该显示一些计算机艺术。只要输出在正常的终端显示中运行良好，就没有限制。然而，输出不应仅限于图形（就像 LOLWUT 5 和 6 实际所做的那样），而可以是生成诗歌和其他非图形的东西。
2. LOLWUT 输出应该完全没用。显示一些有用的 Redis 内部指标不算作有效的 LOLWUT。
3. LOLWUT 输出应该可以快速生成，以便可以在生产实例中调用该命令而不会出现问题。即使用户使用奇怪的参数进行实验，它也应该保持快速。
4. LOLWUT 实现应该是安全的并仔细检查安全性，如果它们接受参数，则抵制不受信任的输入。
5. LOLWUT 必须始终在末尾显示 Redis 版本。

返回值

批量字符串回复（或使用 RESP3 协议时的逐字回复）：包含生成计算机艺术的字符串，以及带有 Redis 版本的文本。

MEMORY DOCTOR

从 4.0.0 开始可用。

时间复杂度： O(1)

MEMORY DOCTOR命令报告 Redis 服务器遇到的不同内存相关问题，并建议可能的补救措施。

返回值

批量字符串回复

MEMORY MALLOC-STATS

从 4.0.0 开始可用。

时间复杂度：取决于分配了多少内存，可能很慢

MEMORY MALLOC-STATS命令提供来自内存分配器的内部统计报告。

此命令当前仅在使用jemalloc作为分配器时实现，并且对所有其他命令评估为良性 NOOP。

返回值

Bulk string reply : 内存分配器的内部统计报告

MEMORY PURGE

从 4.0.0 开始可用。

时间复杂度：取决于分配了多少内存，可能很慢

MEMORY PURGE命令尝试清除脏页，以便分配器可以回收这些脏页。

此命令当前仅在使用jemalloc作为分配器时实现，并且对所有其他命令评估为良性 NOOP。

返回值

简单的字符串回复

MEMORY STATS

从 4.0.0 开始可用。

时间复杂度： O(1)

MEMORY STATS命令返回有关服务器内存使用情况的数组回复。

有关内存使用情况的信息以指标及其各自值的形式提供。报告了以下指标：

• peak.allocated: Redis 消耗的内存峰值（以字节为单位）（参见INFO的 used_memory_peak）
• total.allocated: Redis 使用其分配器分配的总字节数（参见INFO的used_memory）
• startup.allocated: Redis 在启动时消耗的初始内存量（以字节为单位）（请参阅INFO的used_memory_startup）
• replication.backlog：复制积压的字节大小（参见 INFO的repl_backlog_active）
• clients.slaves：所有副本开销的总大小（以字节为单位）（输出和查询缓冲区、连接上下文）
• clients.normal：所有客户端开销（输出和查询缓冲区、连接上下文）的总大小（以字节为单位）
• aof.buffer：AOF 相关缓冲区的总大小（以字节为单位）。
• lua.caches: Lua 脚本缓存开销的总和大小（以字节为单位）
• dbXXX：对于每个服务器的数据库，主字典和过期字典（overhead.hashtable.main和 overhead.hashtable.expires，分别）的开销以字节为单位报告
• overhead.total：所有开销的总和，即startup.allocated, replication.backlog, clients.slaves,clients.normal以及aof.buffer用于管理 Redis 键空间的内部数据结构的总和（请参阅INFO的used_memory_overhead）
• keys.count：存储在服务器中所有数据库中的密钥总数
• keys.bytes-per-key：净内存使用量（total.allocated 减startup.allocated）与keys.count
• dataset.bytes：数据集的大小（以字节为单位），即overhead.total 从中减去total.allocated（参见INFO的used_memory_dataset）
• dataset.percentagedataset.bytes：超出净内存使用的百分比
• peak.percentage:peak.allocated出来 的百分比total.allocated
• fragmentation: 见INFO的mem_fragmentation_ratio

返回值

数组回复：内存使用指标及其值的嵌套列表

关于本手册页中使用的单词 slave 的说明：从 Redis 5 开始，如果不是为了向后兼容，Redis 项目不再使用单词 slave。不幸的是，在这个命令中，slave 这个词是协议的一部分，所以只有当这个 API 被自然弃用时，我们才能删除此类事件。

MEMORY USAGE key [SAMPLES count]

从 4.0.0 开始可用。

时间复杂度： O(N)，其中 N 是样本数。

MEMORY USAGE命令报告键及其值需要存储在 RAM 中的字节数。

报告的使用情况是键值所需的数据和管理开销的内存分配总数。

对于嵌套数据类型，SAMPLES可以提供可选选项，其中 count是采样嵌套值的数量。默认情况下，此选项设置为5。要对所有嵌套值进行采样，请使用SAMPLES 0.

例子

使用 Redis v4.0.1 64 位和jemalloc，空字符串测量如下：

> SET "" ""
OK
> MEMORY USAGE ""
(integer) 51

这些字节目前是纯粹的开销，因为没有存储实际数据，并且用于维护服务器的内部数据结构。较长的键和值显示渐近线性用法。

> SET foo bar
OK
> MEMORY USAGE foo
(integer) 54
> SET cento 01234567890123456789012345678901234567890123
45678901234567890123456789012345678901234567890123456789
OK
127.0.0.1:6379> MEMORY USAGE cento
(integer) 153

返回值

整数回复：以字节为单位的内存使用情况，或者nil当键不存在时。

MODULE LIST

从 4.0.0 开始可用。

时间复杂度： O(N)，其中 N 是加载模块的数量。

返回有关加载到服务器的模块的信息。

返回值

数组回复：已加载模块的列表。列表中的每个元素都代表一个模块，其本身就是属性名称及其值的列表。为每个加载的模块报告以下属性：

• name: 模块名称
• ver: 模块版本

MODULE LOAD path [arg [arg ...]]

从 4.0.0 开始可用。

时间复杂度： O(1)

在运行时从动态库加载模块。

此命令从path参数指定的动态库中加载并初始化 Redis 模块。path应该是库的绝对路径，包括完整的文件名。任何其他参数都未经修改地传递给模块。

注意：模块也可以在服务器启动时loadmodule 使用redis.conf.

返回值

简单字符串回复：OK如果模块已加载。

MODULE UNLOAD name

从 4.0.0 开始可用。

时间复杂度： O(1)

卸载一个模块。

此命令卸载由 指定的模块name。请注意，模块名称由MODULE LIST命令报告，并且可能与动态库的文件名不同。

已知限制：

• 无法卸载注册自定义数据类型的模块。

返回值

简单字符串回复：OK如果模块已卸载。

MONITOR

从 1.0.0 开始可用。

MONITOR是一个调试命令，它流回 Redis 服务器处理的每个命令。它可以帮助理解数据库发生了什么。该命令既可以通过 也可以通过redis-cli使用telnet。

在将 Redis 用作数据库和用作分布式缓存系统时，查看服务器处理的所有请求的能力对于发现应用程序中的错误非常有用。

$ redis-cli monitor
1339518083.107412 [0 127.0.0.1:60866] "keys" "*"
1339518087.877697 [0 127.0.0.1:60866] "dbsize"
1339518090.420270 [0 127.0.0.1:60866] "set" "x" "6"
1339518096.506257 [0 127.0.0.1:60866] "get" "x"
1339518099.363765 [0 127.0.0.1:60866] "eval" "return redis.call('set','x','7')" "0"
1339518100.363799 [0 lua] "set" "x" "7"
1339518100.544926 [0 127.0.0.1:60866] "del" "x"

使用( CtrlSIGINT -C) 停止通过.redis-cli

$ telnet localhost 6379
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
MONITOR
+OK
+1339518083.107412 [0 127.0.0.1:60866] "keys" "*"
+1339518087.877697 [0 127.0.0.1:60866] "dbsize"
+1339518090.420270 [0 127.0.0.1:60866] "set" "x" "6"
+1339518096.506257 [0 127.0.0.1:60866] "get" "x"
+1339518099.363765 [0 127.0.0.1:60866] "del" "x"
+1339518100.544926 [0 127.0.0.1:60866] "get" "x"
QUIT
+OK
Connection closed by foreign host.

MONITOR 未记录的命令

出于安全考虑，MONITOR的输出不记录任何管理命令，并且在命令AUTH中编辑了敏感数据。

此外，命令QUIT也不会被记录。

运行 MONITOR 的成本

因为MONITOR流回所有命令，所以使用它是有代价的。以下（完全不科学的）基准数字说明了运行MONITOR的成本。

未运行 MONITOR的基准测试结果：

$ src/redis-benchmark -c 10 -n 100000 -q
PING_INLINE: 101936.80 requests per second
PING_BULK: 102880.66 requests per second
SET: 95419.85 requests per second
GET: 104275.29 requests per second
INCR: 93283.58 requests per second

MONITOR运行时 的基准测试结果( )：redis-cli monitor > /dev/null

$ src/redis-benchmark -c 10 -n 100000 -q
PING_INLINE: 58479.53 requests per second
PING_BULK: 59136.61 requests per second
SET: 41823.50 requests per second
GET: 45330.91 requests per second
INCR: 41771.09 requests per second

在这种特殊情况下，运行单个MONITOR客户端可以将吞吐量降低 50% 以上。运行更多MONITOR客户端将进一步降低吞吐量。

返回值

非标准返回值，只是将接收到的命令转储到无限流中。

历史

• Redis 版本 >= 6.0.0：AUTH 从命令的输出中排除。
• Redis 版本 >= 6.2.0：可以调用 RESET 来退出监控模式。
• Redis 版本 >= 6.2.4：命令输出中包含AUTH、HELLO、EVAL、EVAL_RO、EVALSHA和EVALSHA_RO。

PSYNC replicationid offset

自 2.8.0 起可用。

从主服务器启动复制流。

Redis 副本调用PSYNC命令以从主服务器启动复制流。

有关 Redis 中复制的更多信息，请查看 复制页面。

返回值

非标准返回值，数据的批量传输，然后是PING和来自主机的写入请求。

REPLCONF

自 3.0.0 起可用。

时间复杂度： O(1)

REPLCONF命令是一个内部命令。Redis 主服务器使用它来配置连接的副本。

REPLICAOF host port

从 5.0.0 开始可用。

时间复杂度： O(1)

REPLICAOF命令可以动态更改副本的复制设置。

如果 Redis 服务器已经作为副本，命令REPLICAOF NO ONE 将关闭复制，将 Redis 服务器变为 MASTER。以正确的形式REPLICAOF主机名端口将使服务器成为在指定主机名和端口上侦听的另一台服务器的副本。

如果服务器已经是某个主服务器的副本，REPLICAOF主机名端口将停止对旧服务器的复制并开始对新服务器进行同步，丢弃旧数据集。

REPLICAOF NO ONE形式将停止复制，将服务器变为 MASTER，但不会丢弃复制。因此，如果旧的 master 停止工作，则可以将副本变为 master，并将应用程序设置为使用这个新的 master 进行读/写。稍后当其他 Redis 服务器修复时，可以将其重新配置为作为副本工作。

返回值

简单的字符串回复

例子

> REPLICAOF NO ONE
"OK"

> REPLICAOF 127.0.0.1 6799
"OK"

RESTORE-ASKING

ROLE

自 2.8.12 起可用。

时间复杂度： O(1)

master通过返回实例当前是否为、slave或来提供有关 Redis 实例在复制上下文中的角色的信息sentinel。该命令还返回有关复制状态的附加信息（如果角色是主或从）或受监控的主名称列表（如果角色是哨兵）。

输出格式

该命令返回一个元素数组。第一个元素是实例的角色，作为以下三个字符串之一：

• “掌握”
• “奴隶”
• “哨兵”

数组的附加元素取决于角色。

主输出

在主实例中调用ROLE时的输出示例：

1) "master"
2) (integer) 3129659
3) 1) 1) "127.0.0.1"
      2) "9001"
      3) "3129242"
   2) 1) "127.0.0.1"
      2) "9002"
      3) "3129543"

主输出由以下部分组成：

• 字符串master。
• 当前主复制偏移量，这是主复制和副本共享的偏移量，以便在部分重新同步中了解复制流中副本需要获取以继续进行的部分。
• 由三个元素组成的数组，表示连接的副本。每个子阵列都包含副本 IP、端口和最后确认的复制偏移量。

副本上的命令输出

在副本实例中调用ROLE时的输出示例：

1) "slave"
2) "127.0.0.1"
3) (integer) 9000
4) "connected"
5) (integer) 3167038

副本输出由以下部分组成：

1. 字符串slave，因为向后兼容（请参阅本页末尾的注释）。
2. 主服务器的 IP。
3. 主设备的端口号。
4. 从master的角度来看的复制状态，可以是connect（实例需要连接到它的master），connecting（master-replica连接正在进行中），sync（master和replica正在尝试执行同步), connected（副本在线）。
5. 到目前为止从副本接收到的数据量，以主复制偏移量表示。

哨兵输出

Sentinel 输出示例：

1) "sentinel"
2) 1) "resque-master"
   2) "html-fragments-master"
   3) "stats-master"
   4) "metadata-master"

哨兵输出由以下部分组成：

1. 字符串sentinel。
2. 此 Sentinel 实例监视的一组主名称。

返回值

数组回复：其中第一个元素是 , 中的一个，master并且附加元素是特定于角色的，如上所示。slavesentinel

例子

redis> ROLE
1) "master"
2) (integer) 0
3) (empty list or set)
redis> 

关于本手册页中使用的单词 slave 的说明：从 Redis 5 开始，如果不是为了向后兼容，Redis 项目不再使用单词 slave。不幸的是，在这个命令中，slave 这个词是协议的一部分，所以只有当这个 API 被自然弃用时，我们才能删除此类事件。

SAVE

从 1.0.0 开始可用。

时间复杂度： O(N) 其中 N 是所有数据库中键的总数

SAVE命令执行数据集的同步保存， 以 RDB 文件的形式生成 Redis 实例内所有数据的时间点快照。

您几乎不想在会阻塞所有其他客户端的生产环境中调用SAVE 。相反，通常使用BGSAVE。但是，如果出现阻止 Redis 创建后台保存子节点的问题（例如 fork(2) 系统调用中的错误），则SAVE命令可能是执行最新数据集转储的最后手段。

有关详细信息，请参阅持久性文档。

返回值

简单字符串回复：命令成功时返回 OK。

SHUTDOWN [NOSAVE|SAVE] [NOW] [FORCE] [ABORT]

从 1.0.0 开始可用。

时间复杂度：保存时O(N)，其中N是保存数据时所有数据库中key的总数，否则O(1)

命令行为如下：

• 如果有任何复制滞后的副本：
  • 通过使用该选项执行CLIENT PAUSE来暂停尝试写入的客户端。WRITE
  • 等待配置的shutdown-timeout（默认 10 秒）以使副本赶上复制偏移量。
• 停止所有客户端。
• 如果配置了至少一个保存点，则执行阻塞保存。
• 如果启用了 AOF，则刷新仅附加文件。
• 退出服务器。

如果启用了持久性，则此命令可确保关闭 Redis 而不会丢失任何数据。

注意：配置为不在磁盘上持久化的 Redis 实例（没有配置 AOF，也没有“保存”指令）不会在SHUTDOWN上转储 RDB 文件，因为通常您不希望仅用于缓存的 Redis 实例在何时阻塞关闭。

另请注意：如果 Redis 接收到其中一个信号SIGTERM和SIGINT，则执行相同的关闭序列。另请参阅信号处理。

修饰符

可以指定可选的修饰符来改变命令的行为。具体来说：

• 即使没有配置保存点，SAVE也会强制执行 DB 保存操作。
• 即使配置了一个或多个保存点， NOSAVE也会阻止数据库保存操作。
• 现在跳过等待滞后的副本，即绕过关闭序列中的第一步。
• FORCE忽略通常会阻止服务器退出的任何错误。有关详细信息，请参阅以下部分。
• ABORT取消正在进行的关闭，并且不能与其他标志结合使用。

SHUTDOWN 失败的情况

配置保存点或指定SAVE修饰符时，如果无法保存 RDB 文件，可能会导致关机失败。然后，服务器继续运行以确保没有数据丢失。这可以使用FORCE修饰符绕过，导致服务器无论如何都退出。

启用 Append Only File 后，关闭可能会失败，因为系统处于不允许立即安全地保存在磁盘上的状态。

通常，如果有一个 AOF 子进程执行 AOF 重写，Redis 会简单地杀死它并退出。但是，在某些情况下这样做是不安全的，除非指定了FORCE修饰符，否则SHUTDOWN命令将被拒绝并出现错误。这发生在以下情况：

• 用户刚刚开启 AOF，服务器触发了第一次 AOF 重写，以便创建初始 AOF 文件。在这种情况下，停止将导致数据集完全丢失：一旦重新启动，服务器可能会启用 AOF，而根本没有任何 AOF 文件。
• 启用 AOF 的副本，与它的主服务器重新连接，执行完全重新同步，并重新启动 AOF 文件，触发初始 AOF 创建过程。在这种情况下，不完成 AOF 重写是危险的，因为从 master 接收到的最新数据集将会丢失。新的 master 实际上甚至可以是一个不同的实例（如果使用REPLICAOF或SLAVEOF命令来重新配置副本），因此完成 AOF 重写并从代表内存中数据集的正确数据集开始是很重要的服务器被终止。

在某些情况下，我们只想尽快终止 Redis 实例，而不管它的内容是什么。在这种情况下，可以使用命令SHUTDOWN NOW NOSAVE FORCE 。在 7.0 之前的版本中，NOW和FORCE标志不可用，正确的命令组合是发送一个CONFIG appendonly no后跟一个SHUTDOWN NOSAVE。如果需要，第一个命令将关闭 AOF，如果有一个活动的，将终止 AOF 重写子。由于不再启用 AOF，第二个命令执行起来不会有任何问题。

将数据丢失的风险降至最低

shutdown-timeout从 Redis 7.0 开始，服务器在关闭之前等待滞后副本最多可配置，默认为 10 秒。在未配置保存点且禁用 AOF 的情况下，这可以最大程度地降低数据丢失的风险。在 7.0 版本之前，在无盘设置中关闭负载较重的主节点更有可能导致数据丢失。为了最大限度地降低此类设置中数据丢失的风险，建议在关闭主节点之前触发手动FAILOVER（或CLUSTER FAILOVER）将主节点降级为副本并将其中一个副本提升为新主节点。

返回值

简单字符串回复：OK如果ABORT已指定且关闭已中止。成功关闭时，由于服务器退出并关闭连接，因此不会返回任何内容。失败时，返回错误。

历史

• Redis 版本 >= 7.0.0：添加了 NOW、FORCE 和 ABORT 修饰符。引入了在退出之前等待滞后的副本。

SLAVEOF host port

从 1.0.0 开始可用。

时间复杂度： O(1)

弃用通知： 从 Redis 版本 5.0.0 开始，此命令被视为已弃用。虽然它不太可能被完全删除，但更喜欢使用 REPLICAOF 来代替它。

关于本手册页中使用的单词 slave 和命令名称的说明：从 Redis 版本 5 开始，如果不是为了向后兼容，Redis 项目不再使用单词 slave。请使用新命令REPLICAOF。命令SLAVEOF将继续工作以实现向后兼容性。

SLAVEOF命令可以动态更改副本的复制设置。如果 Redis 服务器已经充当副本，则命令SLAVEOF NO ONE 将关闭复制，将 Redis 服务器变为 MASTER。以正确的形式SLAVEOF主机名端口将使服务器成为在指定主机名和端口上侦听的另一台服务器的副本。

如果服务器已经是某个主服务器的副本，则 SLAVEOF主机名端口将停止对旧服务器的复制并开始对新服务器进行同步，丢弃旧数据集。

SLAVEOF NO ONE形式将停止复制，将服务器变为 MASTER，但不会丢弃复制。因此，如果旧的 master 停止工作，则可以将副本变为 master，并将应用程序设置为使用这个新的 master 进行读/写。稍后当其他 Redis 服务器修复时，可以将其重新配置为作为副本工作。

返回值

简单的字符串回复

SLOWLOG GET [count]

自 2.2.12 起可用。

时间复杂度： O(N) 其中 N 是返回的条目数

SLOWLOG GET命令按时间顺序从慢速日志返回条目。

Redis 慢日志是一个记录超过指定执行时间的查询的系统。执行时间不包括与客户端交谈、发送回复等 I/O 操作，而只是实际执行命令所需的时间（这是命令执行的唯一阶段，线程被阻塞并且不能同时服务其他请求）。

slowlog-log-slower-than每当命令超过配置指令定义的执行时间阈值时，都会将新条目添加到慢速日志中。慢日志中的最大条目数由slowlog-max-len配置指令控制。

默认情况下，该命令会返回日志中的所有条目。可选count参数限制返回条目的数量，因此该命令最多返回count条目。

慢日志中的每个条目都包含以下六个值：

1. 每个慢速日志条目的唯一渐进标识符。
2. 处理记录的命令的 unix 时间戳。
3. 执行所需的时间量，以微秒为单位。
4. 组成命令参数的数组。
5. 客户端 IP 地址和端口。
6. 客户端名称（如果通过CLIENT SETNAME命令设置）。

该条目的唯一 ID 可用于避免多次处理慢速日志条目（例如，您可能有一个脚本为每个新的慢速日志条目发送电子邮件警报）。该 ID 在 Redis 服务器执行过程中永远不会重置，只有重新启动服务器才会重置它。

数组回复：慢日志条目列表。

历史

• Redis 版本 >= 4.0.0：在回复中添加了客户端 IP 地址、端口和名称。

SLOWLOG LEN

自 2.2.12 起可用。

时间复杂度： O(1)

此命令返回慢日志中的当前条目数。

slowlog-log-slower-than每当命令超过配置指令定义的执行时间阈值时，都会将新条目添加到慢速日志中。慢日志中的最大条目数由slowlog-max-len配置指令控制。一旦 slog 日志达到其最大大小，只要创建新条目，就会删除最旧的条目。可以使用SLOWLOG RESET命令清除慢日志。

整数回复

慢日志中的条目数。

SLOWLOG RESET

自 2.2.12 起可用。

时间复杂度： O(N)，其中 N 是慢日志中的条目数

此命令重置慢日志，清除其中的所有条目。

一旦删除，信息将永远丢失。

简单的字符串回复：OK

SWAPDB index1 index2

从 4.0.0 开始可用。

时间复杂度： O(N)，其中 N 是客户端监视或阻止来自两个数据库的键的计数。

此命令交换两个 Redis 数据库，以便所有连接到给定数据库的客户端立即看到另一个数据库的数据，反之亦然。例子：

SWAPDB 0 1

这会将数据库 0 与数据库 1 交换。与数据库 0 连接的所有客户端将立即看到新数据，就像与数据库 1 连接的所有客户端将看到以前数据库 0 的数据一样。

返回值

简单字符串回复：OK是否正确执行了 SWAPDB。

例子

SWAPDB 0 1

SYNC

从 1.0.0 开始可用。

从主服务器启动复制流。

Redis 副本调用SYNC命令以从主服务器启动复制流。它已被 PSYNC在较新版本的 Redis 中替换。

有关 Redis 中复制的更多信息，请查看 复制页面。

返回值

非标准返回值，数据的批量传输，然后是PING和来自主机的写入请求。

TIME

从 2.6.0 开始可用。

时间复杂度： O(1)

TIME命令以两个项目列表的形式返回当前服务器时间：Unix 时间戳和当前秒内已经过去的微秒数。gettimeofday基本上该接口与系统调用之一非常相似。

返回值

数组回复，具体来说：

包含两个元素的多批量回复：

• unix 时间以秒为单位。
• 微秒。

例子

redis> TIME
1) "1647579322"
2) "750299"
redis> TIME
1) "1647579322"
2) "750867"
redis>