如何管理 Redis

在 2020 年 8 月，我正在研究如何更好的使用 Redis 的时候，看到了 Mark 在 DigitalCoean 上的这 How To Manage a Redis Database，读后觉得对于当时还是小白的我来说，非常有帮助。于是，便发送邮件和 Mark 确认这系列的内容是否可以翻译。得到 Mark 的首肯后，我便着手翻译，奈何期间一直忙于各种事务，近几个月搬家至天津后，才有空余时间来翻译这个系列的教程。虽然时间略晚，但 Mark 写的内容依旧可以帮到你。Mark 也在今年的 6 月份从 Digital Ocean 离开，希望 Mark 以后能够写出更多更好的教程，也希望这个教程能帮到你。
白宦成写于 2022 年 10 月 9 日；

简介

Redis 是一个开源的、运行在内存中的的的键值（Key Value）数据库。作为一个 NoSQL 数据库，Redis 不使用结构化查询语言（SQL,Structured Query Language）。相反，Redis 有自己的一套用于管理和访问数据的命令。

本系列教程涵盖了广泛的 Redis 命令，但它们通常侧重于连接到 Redis 数据库，管理各种数据类型，以及故障排除和调试问题，还有一些其他更具体的功能。它们是以小抄（Cheat Sheet）的形式写的，有对应的例子。我们鼓励你直接跳转到和你要完成的任务相关的章节进行阅读。

Redis 是一个键值（Key-Value）数据库，一种 NoSQL 数据库，其中键作为其相关值的唯一标识符。任何给定的 Redis 实例都包括一些数据库，每个数据库都可以持有各种数据类型的许多不同键。在本教程中，我们将介绍如何选择数据库、在数据库之间移动键以及管理和删除键。

如何管理 Redis 的副本和客户端

Redis 最受欢迎的功能之一是它对副本的支持：任何 Redis 服务器都可以将其数据复制到任何数量的副本中，从而实现高读取扩展性和强大的数据冗余。此外，Redis 被设计成允许多个客户端（默认情况下多达 10000 个）同时连接并进行数据交互，这个特性使得它成为多用户访问统一数据集下的好选择。本教程将介绍用于管理 Redis 客户端和副本的命令。

如何管理 Redis 中的字符串

在 Redis 中，字符串是你能创建和管理的最基本的值的类型。本教程概述了如何创建和检索字符串，以及如何操作字符串键所持有的值。

如何管理 Redis 中的列表

在 Redis 中，除非显式指明，否则列表是类似于链接列表（linked list）按插入顺序排序的字符串的集合。本教程详细介绍了如何创建列表以及从列表中检索和删除元素。

如何管理 Redis 中的哈希散列（Hash）

Redis 哈希散列是一种数据类型，它表示一个字符串字段和一个字符串值之间的映射。一个哈希可以容纳许多键值对，并且被设计成不占用太多空间，使其成为代表数据对象的理想选择。例如，一个哈希值可能代表一个客户，并包括 "姓名"、"地址"、"电子邮件 "或 "客户 ID "等字段。本教程将介绍如何在 Redis 中管理哈希，包括创建哈希、检索和删除哈希中的数据。

如何管理 Redis 中的 Sets 集合

Redis 中的 Sets 集合是存储在一个给定键上的字符串的集合。当存储在一个集合中时，一个单独的记录值被称为一个成员。与列表不同，集合是不允许重复值的无序结果。本教程解释了如何创建集合，检索和删除成员，以及比较不同集合的成员。

如何管理 Redis 中的 Sorted Sets 有序集合

在 Redis 中，有序集合是一种与集合类似的数据类型，都是不重复的字符串组。不同的是，排序集的每个成员都与一个分数相关，允许它们从最小的分数到最大的分数进行排序或排名。本教程解释了如何创建排序集，检索和删除其成员，以及基于现有的排序集创建新的排序集。

如何在 Redis 中管理事务

Redis 允许你设计一连串的命令，并一个接一个地运行它们，这种程序被称为事务。客户端不可能在事务块执行时运行命令，这确保了事务被视为一个单独的隔离操作。本教程介绍了如何执行和取消事务，还包括一些通常与事务有关的陷阱的信息。

如何让 Redis 中的键过期

Redis 是一个开源的内存键值数据存储。根据你的应用程序的需要，可能会出现这样的情况：你已经设置了一个键，但你知道在一定的时间过后你会想删除它。本教程解释了如何设置键的过期，检查一个键还有多长时间过期，以及取消一个键的过期设置。

如何在 Redis 中排查问题

Redis 带有几个可以帮助排除故障和调试问题的命令。由于其作为内存键值存储的性质，这些命令中有许多侧重于内存管理，但也有一些命令对于提供 Redis 服务器状态的概述很有价值。本教程将详细介绍如何使用其中一些命令来帮助诊断和解决你在使用 Redis 时可能遇到的问题。

如何在命令行中修改 Redis 的配置

有些时候，你可能想临时改变你的 Redis 实例的行为。Redis 有几个命令，允许你直接从 redis-cli 界面对 Redis 服务器的配置设置进行修改。本教程将介绍其中一些命令，并解释如何使这些配置永久化。

作者介绍

Mark Drake(@mdrake)，Developer Education + Documentation at Chainguard。

译者介绍

白宦成 (@bestony)，Linux 中国技术社区技术负责人，开发者生态顾问，资深技术专家。曾就职于腾讯开发者关系部门，是多个开源软件项目的作者或管理者。

授权说明

本作品采用知识共享署名-非商业性使用 - 相同方式共享 4.0 国际许可协议进行许可。

如何连接到一个 Redis 数据库

源地址：https://www.digitalocean.com/community/cheatsheets/how-to-connect-to-a-redis-database
作者：Mark Drake

简介

Redis 是一个开源的、运行在内存中的键值数据库。无论你是在本地安装了 Redis 还是在使用一个远程实例，你都需要连接到它来执行某些操作。在本教程中，我们将介绍如何从命令行连接到 Redis、如何验证和测试你的连接以及如何关闭 Redis 连接。

如何使用这个教程

这个教程是以小抄（Cheat Sheet）的形式写的，有对应的例子。我们鼓励你直接跳转到和你要完成的任务相关的章节进行阅读。

这个教程中的命令在 Ubuntu 18.04 中的 Redis 4.0.9 版本完成测试。如果你需要建设一个同样的环境，可以参考我们的如何在 Ubuntu 18.04 上安装并加固 Redis 中的 Step 1 来安装 Redis。我们将通过 Redis 命令行界面redis-cli运行这些命令，来演示这些命令的行为。请注意，如果你使用不同的 Redis 工具--例如Redli —— 某些命令的实际输出可能有所不同。

此外，你还可以使用一个代管的 Redis 数据库实例来测试这些命令。但需要注意的是，根据你的数据库服务提供商的限制，这个教程中的某些命令可能运行效果和教程不一致。如果想要使用 DigitalOcean 提供的代管数据库，可以查看我们的代管数据库产品文档。使用代管 Redis 数据库实例时，你必须安装 Redli或设置 TLS 隧道来通过 TLS 链接到代管数据库。

连接到 Redis

如果你在本地安装了 redis-server，你可以使用 redis-cli 命令连接到 Redis 实例：

$ redis-cli

这将会使你进入 redis-cli 的 交互模式，在交互模式下，你将会拥有一个读取 - 求值 - 输出循环（REPL），你可以在里面运行 Redis 的内建命令并获得命令的输出。

在交互式模式下，你的命令行提示符将改变以展示你的连接。在这个例子和本指南中的其他例子中，提示符显示连接到本地托管的 Redis 实例（127.0.0.1），并通过 Redis 的默认端口（6379）访问。

127.0.0.1:6379>

在交互式模式下运行 Redis 命令的另一种方法是将它们作为 redis-cli 命令的参数运行，比如说：

$ redis-cli redis_command

如果你想要连接到一个远程的 Redis 数据库，你可以分别使用 -h 来设定主机地址，使用 -p来设定数据库端口号。另外，如果你将你的 Redis 数据库配置为需要密码才能连接，你可以在命令后面加上-a，以便进行认证。

$ redis-cli -h host -p port_number -a password

如果你设置了 Redis 密码，即使客户在其 redis-cli 命令中不包括 -a，他们也能连接到 Redis。然而，在他们进行身份验证之前，他们将不能添加、更改或查询数据。要在连接后进行认证，请使用 auth 命令，并在后面加上密码。

127.0.0.1:6379> auth password

如果传递给 auth 的密码是正确的，该命令将返回 OK。否则，它将返回一个错误。

如果你正在使用管理的 Redis 数据库，你的云提供商可能会给你一个以 redis:// 或 rediss:// 开头的 URI，你可以用它来访问你的数据存储。如果连接字符串以 redis:// 开头，你可以把它作为参数加入 redis-cli 进行连接。

然而，如果你有一个以 rediss:// 开头的连接字符串，这意味着你的管理数据库需要通过 TLS/SSL 连接。redis-cli 不支持 TLS 连接，所以你需要使用一个支持 rediss 协议的不同工具，以便用 URI 连接。对于 DigitalOcean 代管的数据库，需要通过 TLS 进行连接，我们建议使用 Redli 来访问 Redis 实例。

使用下面的语法，用 Redli 连接到一个数据库。请注意，这个例子包括 -tls 选项，它指定连接应通过 TLS 进行，以及 -u，它声明其后参数将是一个连接 URI。

$ redli --tls -u rediss://connection_URI

如果你试图连接到一个不可用的实例，redis-cli 将进入断开连接模式。提示符将展示这一点。

not connected>

当前处于断开链接模式时，每次你输入命令时，Redis 将会尝试重新连接。

测试连接

ping命令对于测试与数据库的连接是否是活的很有用。请注意，这是一个针对 Redis 的命令，与 [ping网络工具]（https://en.wikipedia.org/wiki/Ping_(networking_utility)）不同。然而，两者的功能相似，都是用来检查两台机器之间的连接。

如果连接时活跃的且不含任何参数时，ping命令将返回 PONG。

127.0.0.1:6379> ping

PONG

如果你为ping命令提供了一个参数，当连接是活跃的时，它将返回该参数以取代PONG

127.0.0.1:6379>  ping "hello Redis"

"hello Redis"

当你在断开连接模式下使用ping命令时，它将返回如下内容：

not connected> ping

Could not connect to Redis at host:port: Connection refused

请注意，Redis 内部也使用ping来测量延迟。

断开 Redis 连接

想要断开连接，使用quit命令：

127.0.0.1:6379> quit

使用exit也可以退出连接

127.0.0.1:6379> exit

quit 和 exit 都会关闭连接，但只有在所有待处理的回复都被写入客户端后才会关闭。

总结

本指南详细介绍了用于建立、测试和关闭与 Redis 服务器连接的一些命令。

如何管理 Redis 数据库以及 Keys

源地址：https://www.digitalocean.com/community/cheatsheets/how-to-manage-redis-databases-and-keys
作者：Mark Drake

简介

Redis 是一个开源的、运行在内存中的键值数据库。键值对数据库是一种将 key 作为相关 value 唯一标识的 NoSQL 数据库。任何一个 Redis 示例都包含了数个可以容纳不同数据类型键的 数据库。在这个教程中，我们将介绍如何选择数据库、在数据库之间移动键值对以及管理和删除键值对。

如何使用这个教程

这个教程是以小抄（Cheat Sheet）的形式写的，有对应的例子。我们鼓励你直接跳转到和你要完成的任务相关的章节进行阅读。

管理数据库

默认情况下，一个 Redis 实例支持 16 个逻辑数据库。这些数据库之间是相互隔离的，你在一个数据库中执行命令时，不会影响存储在同一 Redis 实例中的其他数据库中的任何数据。

Redis 数据库的编号从 0 到 15 ，默认情况下，你连接到 Redis 实例时会使用数据库 0。你可以在连接成功后，使用 select 命令变更你所使用的数据库。

127.0.0.1:6379> select 15

如果你选择了 0 之外的数据库，它将会展示在 redis-cli 命令行提示符上。

127.0.0.1:6379[15]>

如果一个数据库想要和另外一个数据库交换数据，可以使用 swapdb 命令。下面的这个例子将数据库 6 和数据库 8 的数据进行交换，与这两个数据库相连的客户端马上就能看到对应的变化。

127.0.0.1:6379> swapdb 6 8

如果交换成功，swapdb 将会返回一个 OK。

如果你想把一个键值对转移到不同的 Redis 实例，你可以运行migrate 命令。这个命令确保键值出现在目标实例之后，才会从源实例中删除键值对。当你运行 migrate时，该命令必须按顺序输入以下参数：

目标数据库的主机名或 IP 地址
目标数据库的端口号
你要迁移的键值对的 Key 的名称
目标数据库中用于存储迁移数据的数据库编号
超时时间，以毫秒为单位，它定义了两台机器之间的最大空闲通信时间。注意，这并不是操作的时间限制，只是操作应该在定义的时间内提供返回。

举例说明：

127.0.0.1:6379> migrate 203.0.113.0 6379 key_1 7 8000

此外，migrate 还支持如下选项，你可以在超时参数后添加：

COPY：设置迁移不从源数据库中删除键值对。
REPLACE：设置迁移时，如果目标数据库中已经存在相同的键值对，那么就替换它。
KEYS：如果想要迁移多个键值对，你可以输入一个空字符串 ("")，然后使用 keys 命令的语法来迁移任何符合范式的键值对。更多关于keys工作原理的信息，请参见我们的教程如何在 Redis 中排查问题。

管理 Keys

有一些命令对任何数据类型都是有效的，它们对于管理键来说非常有用。我们将在本节中介绍其中的几个。

rename 将重命名指定的键。如果执行成功，它将返回 OK

127.0.0.1:6379> rename old_key new_key

你可以使用 randomkey 来从当前选中的数据库中返回一个随机的键。

127.0.0.1:6379> randomkey

输出

"any_key"

使用 type 来判断对应键的数据类型。这个命令的输出可能是string, list, hash, set, zset, 或 stream:

127.0.0.1:6379> type key_1

输出

"string"

如果对应的键不存在，type将会返回 none。

你可以用 move 命令将一个单独的键移动到 Redis 实例中的另一个数据库中。例如，要将 key_1 移动到数据库 8，你可以执行以下命令：

127.0.0.1:6379> move key_1 8

如果移动键成功，move 将会返回 OK。

删除 Keys

要删除一个或多个任何数据类型的键，使用 del 命令，后面跟一个或多个你想删除的键。

127.0.0.1:6379> del key_1 key_2

如果这个命令成功地删除了键，它将返回(integer) 1，否则，它将返回 (integer) 0`。

unlink 命令的功能与 del 类似，不同的是 del 会在服务器回收钥匙所占用的内存时阻塞客户端。如果被删除的键是与一个小对象相关联的，del 回收内存所需的时间是非常小的，阻塞时间甚至可能不会被注意到。

然而，如果你要删除的键与许多对象相关联，例如一个有数千或数百万字段的哈希值，这就会变得很不方便。删除这样一个键可能需要明显的长时间，而且你将被阻塞执行任何其他操作，直到它从服务器的内存中完全删除。

然而，unlink 首先会确定删除键所占用的内存的成本。如果它是小的，那么 unlink 的功能就和 del 一样，同时也阻塞了客户端。然而，如果为一个键分配内存的成本很高，unlink 将通过创建另一个线程来异步删除该键，并在后台逐步回收内存而不阻塞客户端。

127.0.0.1:6379> unlink key_1

由于它在后台运行，尽管 del 在大多数情况下也够用，一般仍建议你使用 unlink 从你的服务器上删除键，以减少客户端的错误。

警告：以下两个命令是比较危险的。flushdb 和 flushall 命令将分别不可逆转地删除单个数据库中的所有键和 Redis 服务器上每个数据库中的所有键。我们建议你只在你绝对确定要删除数据库或服务器中的所有键时才运行这些命令。

出于安全考虑，你可以选择将这些命令重命名为不容易被意外运行的命令。

要删除所选数据库中的所有键，使用 flushdb 命令：

127.0.0.1:6379> flushdb

要删除 Redis 服务器上每个数据库中的所有键（包括当前选定的数据库），运行 flushall：

127.0.0.1:6379> flushall

flushdb 和 flushall 都支持 async 选项，来实现异步删除单个数据库或集群中每个数据库的所有键。加入 async 选项后，它们的功能类似于 unlink 命令，它们将创建一个新的线程，在后台逐步释放内存。

备份你的数据库

要创建当前所选数据库的备份，你可以使用 save 命令：

127.0.0.1:6379> save

这将把当前数据集的快照导出为一个 .rdb 文件，这是一个数据库转储文件，以内部压缩的序列化格式保存数据。

save 是同步运行的，并且会阻塞任何其他连接到数据库的客户端。因此，在save 命令文档中建议，如非必要，在生产环境中不应该运行这个命令。它更建议使用 bgsave 命令，Redis 将会 Fork 数据库：父进程将继续为客户提供服务，而子进程在退出前保存数据库：

127.0.0.1:6379> bgsave

注意，如果客户端在 bgsave 操作发生时添加或修改数据，这些变化不会被捕捉到快照中。

你也可以通过配置 Redis，修改数据库最小变更次数，让 Redis 在特定时间后自动保存快照（称为snapshotting或 RDB 模式）。这个功能被称为保存点。下述 redis.conf 中的保存点设置默认启用。

# /etc/redis/redis.conf

. . .
save 900 1
save 300 10
save 60 10000
. . .
dbfilename "nextfile.rdb"
. . .

通过这些设置，当有 1 个键被改变，Redis 将每隔 900 秒将数据库的快照导出到 dbfilename 参数定义的文件中；当有 10 个键被改变，则每隔 300 秒，当有 10000 个键被改变，则每隔 60 秒。

你也可以使用 shutdown 命令来备份你的 Redis 数据，并关闭连接。这个命令将阻止每一个连接到数据库的客户端，然后在至少配置了一个保存点的情况下执行 save 操作，它将阻止客户端做任何变更，并将当前状态的数据库导出到 .rdb 文件。

此外，如果 append-only-file 模式被启用，shutdown命令将在退出前刷新对 Redis 的 append-only 文件的修改。append-only-file(AOF) 模式可以在每次快照后，在一个以.aof结尾的文件中创建服务器上的每个写操作日志。AOF 和 RDB 模式可以在同一台服务器上启用，这两种持久化方法是备份数据的有效方式。

简而言之，"shutdown "命令本质上是一个阻塞的 "save "命令，它也会刷新所有最近的变化到 append-only 文件并关闭与 Redis 实例的连接。

警告：shutdown 比较危险。通过阻塞客户端，它使 Redis 中的数据对于依赖它的用户和应用程序不可用。我们建议你只在测试 Redis 的行为或你绝对确定你想要阻塞所有 Redis 实例的客户端时使用这个命令。

事实上，你可能需要重命名这个命令，来避免意外执行这个命令。

127.0.0.1:6379> shutdown

如果你没有配置任何保存点，但仍然希望 Redis 执行 save 操作，请在 shutdown 命令中添加 save 参数。

127.0.0.1:6379> shutdown save

如果你已经配置了至少一个保存点，但你想在不执行保存的情况下关闭 Redis 服务器，你可以在命令中添加nosave参数。

127.0.0.1:6379> shutdown nosave

注意，随着时间的推移，append-only 的文件可能会变得很长，但你可以通过编辑redis.conf文件，配置 Redis 根据某些变量重写该文件。你也可以通过运行bgrewriteaof命令来要求 Redis 更新 append-only 文件。

127.0.0.1:6379> bgrewriteaof

bgrewriteaof 将创建全新的命令集，使数据库恢复到当前状态。正如这个命令的名字所暗示的，它将在后台运行。但如果另外一个持久化命令已经在后台运行，这个命令必须要在 Redis 服务器执行 bgrewriteaof 前完成。

总结

本指南详细介绍了一些用于管理数据库和密钥的命令。

源地址：https://www.digitalocean.com/community/cheatsheets/how-to-manage-replicas-and-clients-in-redis
作者：Mark Drake

如何管理 Redis 的副本和客户端

Introduction

Redis 是一个开源的、运行在内存中的键值数据库。Redis 最受欢迎的功能之一是它对副本的支持：任何 Redis 服务器都可以将其数据复制到任何数量的副本中，从而实现高读取扩展性和强大的数据冗余。此外，Redis 被设计成允许多个客户端（默认情况下多达 10000 个）同时连接并进行数据交互，这个特性使得它成为多用户访问统一数据集下的好选择。本教程将介绍用于管理 Redis 客户端和副本的命令。

如何使用这个教程

这个教程是以小抄（Cheat Sheet）的形式写的，有对应的例子。我们鼓励你直接跳转到和你要完成的任务相关的章节进行阅读。

注意：Redis 项目文档中使用 master 和 slave 来区分不同副本，虽然项目的贡献者正在采取措施来在不影响兼容性的情况下改变这个用法。Digital Ocean 一般倾向于使用替代词汇 primary 和 replica。

这个教程将默认使用 primary 和 replica ，但某些特定情况下，无法完全避免 master 和 slave 的用法。

Managing Replicas

Redis 特点之一是它的内置副本。当使用副本时，Redis 将会创建主实例的精准拷贝。出现断连后，这些次要的副本将会在重新连接到主示例时，将会始终保持和主实例的精准拷贝。

如果你不确定你当前连接的 Redis 实例是主实例还是副本实例，你可以执行 role命令查看：

127.0.0.1:6379> role

如果你使用了 Redis Sentinel，这个命令可能会返回 maste、slave 或 sentinel 作为结果。

要动态地将 Redis 实例指定为另一个实例的副本，请运行 replicaof 命令。此命令以预期的主服务器的主机名或 IP 地址和端口作为参数：

127.0.0.1:6379> replicaof hostname_or_IP port

如果服务器已经是另一个主服务器的副本，它将停止复制旧服务器并立即开始与新服务器同步，并丢弃旧数据集。

要将副本变回主副本，请运行以下 replicaof 命令：

127.0.0.1:6379> replicaof no one

这将阻止实例复制主服务器，但不会丢弃它已经复制的数据集。此语法在原主节点失败的情况下很有用。在故障主节点的副本上运行 replicaof noone 后，当前节点可以用作新的主节点，并配置自己的副本作为故障保护。

注意： 在 5.0.0 版本之前，Redis 此命令的名字是 slaveof。

管理客户端

客户端 是连接到服务器以访问服务的任何机器或软件。Redis 附带了几个命令，可帮助跟踪和管理客户端连接。

client list 命令返回一组易读的、关于当前客户端连接的信息。

127.0.0.1:6379> client list

输出

"
id=18165 addr=[2001:db8:0:0::12]:47460 fd=7 name=jerry age=72756 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=0 qbuf-free=0 obl=0 oll=0 omem=0 events=r cmd=ping
id=18166 addr=[2001:db8:0:1::12]:47466 fd=8 name= age=72755 idle=5 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=0 qbuf-free=0 obl=0 oll=0 omem=0 events=r cmd=info
id=19381 addr=[2001:db8:0:2::12]:54910 fd=9 name= age=9 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=26 qbuf-free=32742 obl=0 oll=0 omem=0 events=r cmd=client
"

以下是每个字段的含义：

id: 唯一的 64 位客户端 ID
name: 客户端连接的名称，由之前执行的client setname命令定义
addr: 客户端连接的地址和端口
fd: 文件描述符，对应于客户端连接的 Socket
age: 以秒为单位，客户端连接的总时长。
flags: 一组一个或多个单字符标志，提供有关客户端的更详细的信息；可以查看 client list 命令文档了解更多信息
db: 客户端连接的当前数据库 ID 号（可以从0到15）
sub: 客户端订阅的频道数量
psub: 客户端模式匹配订阅的数量
mutli: 客户端在事务中排队的命令数。（-1表示客户端没有开始事务；0表示只开始了一个事务，且没有任何命令在队列中）。
qbuf: 客户端的查询缓冲区长度，0 表示它没有待处理的查询。
qbuf-free: 客户端查询缓冲区的可用空间量，0表示查询缓冲区已满
obl: 客户端的输出缓冲区长度
oll: 客户端输出列表的长度，当缓冲区满时将会进行排队
omem: 客户端输出缓冲区使用的内存
events: 客户端的文件描述符事件，这些可以是 r 表示“可读”，“w”表示“可写”，或两者兼而有之。
cmd: 客户端运行的最后一条命令

设置客户端名称对于调试任何使用 Redis 的应用程序中出现的连接泄漏很有用。默认情况下，每个新连接都没有设置名称，但可以使用client setname为当前客户端连接设置名称。客户端名称的长度没有限制，但 Redis 通常将字符串长度限制为 512 MB。需要注意的是，客户端名称不能包含空格：

127.0.0.1:6379> client setname elaine

使用 client getname 可以获取当前客户端的名称

127.0.0.1:6379> client getname

输出

"elaine"

使用 client id 命令可以获取到当前客户端的连接 ID

127.0.0.1:6379> client id

输出

(integer) "19492"

Redis 客户端 ID 从不重复，并且是单调递增的。这意味着如果一个客户端的 ID 大于另一个客户端，那么它是在另一个客户端建立以后建立的。

阻塞客户端并关闭客户端连接

副本系统通常被描述为_同步_或_异步_的。在同步复制中，每当客户端添加或更改数据时，它必须从一定数量的副本接收某种确认，以便将更改注册为已提交。这有助于防止节点发生数据冲突，但它是以延迟为代价的，因为客户端必须等待执行另一个操作，直到它收到一定数量的副本的回复。

另一方面，在异步复制中，一旦数据写入本地存储，客户端就会看到操作完成的确认。但是，这与副本实际写入数据的时间之间可能存在延迟。如果其中一个副本在写入更改之前发生故障，则该写入将永远丢失。因此，虽然异步复制允许客户端继续执行操作而不会因等待副本而产生延迟，但它可能会导致节点之间的数据冲突，并且可能需要数据库管理员额外的工作来解决这些冲突。

由于注重性能和低延迟，Redis 默认实现异步复制。但是，你可以使用 wait 命令模拟同步复制。 wait 将当前客户端连接阻塞指定的时间量（以毫秒为单位），直到所有先前的写入命令都成功传输并被指定数量的副本接受。此命令使用以下语法：

127.0.0.1:6379> wait number_of_replicas number_of_milliseconds

例如，如果你想阻止你的客户端连接，直到所有先前的写入在 30 毫秒超时内被至少 3 个副本注册，你的 wait 语法将如下所示：

127.0.0.1:6379> wait 3 30

wait 命令返回一个整数，表示确认写入命令的副本数量，即使不是每个副本都这样做：

输出

要解除之前通过 wait、brpop 或 xread命令对先前客户端连接的阻塞，都可以使用以下语法运行client unblock命令：

127.0.0.1:6379> client unblock client_id

要暂时挂起当前连接到 Redis 服务器的每个客户端，可以使用 client pause 命令。这在你需要以可控的方式更改 Redis 设置的情况下很有用。例如，如果你将其中一个副本提升为主实例，你可能会提前暂停每个客户端，以便你可以提升副本并让客户端连接到它作为新的主实例，而不会丢失该过程中的任何写入操作。

client pause 可以指定要暂停客户端的时间量（以毫秒为单位）。以下示例将暂停所有客户端一秒钟：

127.0.0.1:6379> client pause 1000

client kill 允许你基于多个不同的过滤器关闭单个连接或一组特定连接。语法如下所示：

127.0.0.1:6379> client kill filter_1 value_1 ... filter_n value_n

在 Redis 2.8.12 及更高版本中，可以使用以下过滤器：

addr: 允许你关闭来自指定 IP 地址和端口的客户端连接
client-id: 允许你根据其唯一 ID 字段关闭客户端连接
type: 关闭特定类型的每个客户端，可以是 normal、master、slave 或 pubsub
skipme: 此过滤器的值选项是 yes 和 no：
- 如果指定了 no，调用 client kill 命令的客户端将不会被跳过，如果其他过滤器适用于它，它也将被杀死。。
- 如果指定了yes，将跳过运行该命令的客户端，kill 命令对客户端没有任何影响。默认情况下，skipme 的值是 yes

总结

本指南详细介绍了一些用于管理 Redis 客户端和副本的命令。

如何管理 Redis 中的字符串

源地址：https://www.digitalocean.com/community/cheatsheets/how-to-manage-strings-in-redis
作者：Mark Drake

简介

Redis 是一个开源的、运行在内存中的键值数据库。在 Redis 中，字符串是你能创建和管理的最基本的值的类型。本教程概述了如何创建和检索字符串，以及如何操作字符串键所持有的值。

如何使用这个教程

这个教程是以小抄（Cheat Sheet）的形式写的，有对应的例子。我们鼓励你直接跳转到和你要完成的任务相关的章节进行阅读。

创建以及管理字符串

保存字符串的键只能保存一个值；你不能在一个键中存储多个字符串。但是，Redis 中的字符串是二进制安全的，这意味着 Redis 字符串可以保存任何类型的数据，从字母、数字、字符到 JPEG 图像。唯一的限制是字符串的长度必须小于等于 512MB。

要创建字符串，请使用 set 命令。例如，以下 set 命令创建一个名为 key_Welcome1 的键，其值为字符串 "Howdy"：

127.0.0.1:6379> set key_Welcome1 "Howdy"

输出

OK

要在一个命令中设置多个字符串，请使用 mset：

127.0.0.1:6379> set key_Welcome1 "Howdy"

你还可以使用 append 命令创建字符串：

127.0.0.1:6379>  append key_Welcome4 "welcome to Texas"

如果字符串创建成功，append 将输出一个整数，该整数等于字符串包含的字符数：

输出

 (integer) 16

注意 append 也可以用来改变字符串的内容。这部分信息可以参考下方的操作字符串。

查询字符串

使用 get 命令可以获取字符串的值：

127.0.0.1:6379>  get key_Welcome1

输出

 "Howdy"

想要在一个命令当中获取多个字符串键的值，可以使用 mget 命令：

127.0.0.1:6379>  mget key_Welcome1 key_Welcome2 key_Welcome3 key_Welcome4

输出

 1) "Howdy"
 2) "there"
 3) "partners,"
 4) "welcome to Texas"

对于传递给mget的每个不包含字符串值或根本不存在的键，该命令将返回 nil。

操作字符串

如果字符串由整数构成，你可以运行 incr 命令对其值 +1：

127.0.0.1:6379>  set key_1 3
127.0.0.1:6379>  incr key_1

输出

 (integer) 4

同样，你可以使用 incrby 命令将数字字符串的值增加一个特定的增量：

127.0.0.1:6379>  incrby key_1 16

输出

 (integer) 20

decr 和 decrby 命令的工作方式相同，但它们减少了存储在数字字符串中的值：

127.0.0.1:6379>  decr key_1

输出

 (integer) 19

127.0.0.1:6379>  decrby key_1 16

输出

 (integer) 3

如果字母字符串已经存在，append 会将值附加到现有值的末尾并返回字符串的新长度。为了说明，以下命令将 ", y'all" 附加到键 key_Welcome4 保存的字符串中，所以现在字符串将显示为 "welcome to Texas, y'all"：

127.0.0.1:6379>  append key_Welcome4 ", y'all"

输出

 (integer) 15

你还可以将整数附加到包含数值的字符串。以下示例将 45 附加到 3，即 key_1 中保存的整数，因此它将保存 345。在这种情况下，append 也会返回字符串的新长度，而不是它的新值：

127.0.0.1:6379>  append key_1 45

输出

 (integer) 3

因为这个键仍然只保存一个数值，所以你可以对其执行 incr 和 decr 操作。你还可以将字母字符附加到整数字符串，但如果这样做，则在字符串上运行 incr 和 decr 将产生错误，因为字符串值不再是整数。

总结

本指南详细介绍了一些用于在 Redis 中创建和管理字符串的命令。

如何管理 Redis 中的列表

源地址：https://www.digitalocean.com/community/cheatsheets/how-to-manage-lists-in-redis
作者：Mark Drake

简介

Redis 是一个开源的、运行在内存中的键值数据库。在 Redis 中，除非显式指明，否则列表是类似于链接列表（linked list）按插入顺序排序的字符串的集合。本教程详细介绍了如何创建列表以及从列表中检索和删除元素。

如何使用这个教程

这个教程是以小抄（Cheat Sheet）的形式写的，有对应的例子。我们鼓励你直接跳转到和你要完成的任务相关的章节进行阅读。

创建列表

一个键只能保存一个列表，每个列表可以保存超过 40 亿个元素。Redis 从左到右读取列表，你可以使用 lpush 命令将新列表元素添加到列表的头部（"左"端）或使用 rpush 将新列表元素添加到列表的尾部（"右"端）。你还可以使用 lpush 或 rpush 创建一个新列表：

127.0.0.1:6379>  lpush key value

这两个命令都将输出一个整数，以显示列表中有多少元素。为了说明，运行以下命令来创建一个包含格言"I think therefore I am"的列表：

127.0.0.1:6379>  lpush key_philosophy1 "therefore"
127.0.0.1:6379>  lpush key_philosophy1 "think"
127.0.0.1:6379>  rpush key_philosophy1 "I"
127.0.0.1:6379>  lpush key_philosophy1 "I"
127.0.0.1:6379>  rpush key_philosophy1 "am"

最后一个命令的返回如下：

输出

 (integer) 5

请注意，你可以使用单个 lpush 或 rpush 语句添加多个列表元素：

127.0.0.1:6379>  rpush key_philosophy1 "-" "Rene" "Decartes"

lpushx 和 rpushx 命令也用于将元素添加到列表中，但仅在给定列表已经存在时才有效。如果任一命令失败，它将返回 (integer) 0：

127.0.0.1:6379>  rpushx key_philosophy2 "Happiness" "is" "the" "highest" "good" "-" "Aristotle"

输出

 (integer) 0

要更改列表中的现有元素，请运行 lset 命令，后跟键名、要更改的元素的索引以及新的值：

127.0.0.1:6379>  lset key_philosophy1 5 "sayeth"

如果你尝试将列表元素添加到不包含列表的现有键中，则会导致数据类型冲突并返回错误。例如，下面的 set 命令会创建一个包含字符串的键，因此下面尝试使用 lpush 向其中添加列表元素的操作将会失败：

127.0.0.1:6379>  set key_philosophy3 "What is love?"
127.0.0.1:6379>  lpush key_philosophy3 "Baby don't hurt me"

输出

 (error) WRONGTYPE Operation against a key holding the wrong kind of value

目前还无法将 Redis 键值对从一种数据类型转换为另一种数据类型，因此要将 key_philosophy3 转换为列表，你需要删除键并使用 lpush 或 rpush 命令重新开始。

从列表中提取元素

如果想要从列表中提取一系列元素，可以使用包含一个开始偏移量和结束偏移量的 lrange 命令来获取。每个偏移量都是从零开始的，这意味着0代表列表中的第一个元素，1代表下一个元素，依此类推。

以下命令将返回上一节中创建的示例列表中的所有元素：

127.0.0.1:6379>  lrange key_philosophy1 0 7

输出

1) "I"
2) "think"
3) "therefore"
4) "I"
5) "am"
6) "sayeth"
7) "Rene"
8) "Decartes"

传递给 lrange 的偏移量也可以是负数。在这种情况下使用时，-1 表示列表中的最后一个元素，-2 表示列表中的倒数第二个元素，依此类推。以下示例返回 key_philosophy1 中保存的列表的最后三个元素：

127.0.0.1:6379>  lrange key_philosophy1 -3 -1

输出

 1) "I"
 2) "am"
 3) "sayeth"

要从列表中获取单个元素，可以使用 lindex 命令。但是，此命令要求你提供元素的索引作为参数。与 lrange 一样，索引是从零开始的，这意味着第一个元素在索引 0 处，第二个在索引 1 处，依此类推：

127.0.0.1:6379>  lindex key_philosophy1 4

输出

 "am"

要找出给定列表中有多少元素，请使用 llen 命令，它是“list length”:

127.0.0.1:6379>  llen key_philosophy1

输出

 (integer) 8

如果存储在给定键的值不存在，llen 将返回错误。

从列表中删除元素

lrem 命令删除与给定值匹配的定义数量的出现中的第一个。要测试这个功能，需要先创建以下列表：

127.0.0.1:6379>  rpush key_Bond "Never" "Say" "Never" "Again" "You" "Only" "Live" "Twice" "Live" "and" "Let" "Die" "Tomorrow" "Never" "Dies"

以下 lrem 命令将删除第一次出现的 "Live"：

127.0.0.1:6379>  lrem key_Bond 1 "Live"

此命令将输出从列表中删除的元素数量：

输出

 (integer) 1

传递给“lrem”命令的数字也可以是负数。以下命令将删除最后两次出现的 "Never"：

127.0.0.1:6379>  lrem key_Bond -2 "Never"

输出

 (integer) 2

lpop 命令从列表中删除并返回第一个或“最左边”的元素：

127.0.0.1:6379>  lpop key_Bond

输出

 "Never"

同样，要从列表中删除并返回最后一个或“最右边”的元素，请使用 rpop：

127.0.0.1:6379> rpop key_Bond

输出

 "Dies"

Redis 还包括 rpoplpush 命令，该命令从列表中删除最后一个元素并将其推送到另一个列表的开头：

127.0.0.1:6379>  rpoplpush key_Bond key_AfterToday

输出

 "Tomorrow"

如果传递给 rpoplpush 命令的源键和目标键相同，它将实现旋转列表中的元素的功能。

总结

本指南详细介绍了一些可用于在 Redis 中创建和管理列表的命令。

如何管理 Redis 中的哈希散列（Hash）

源地址：https://www.digitalocean.com/community/tutorials/how-to-manage-hashes-in-redis
作者：Mark Drake

简介

Redis 是一个开源的、运行在内存中的键值数据库。Redis 的 哈希散列 是一种数据类型，它表示一个字符串字段和一个字符串值之间的映射。一个哈希可以容纳许多键值对，并且被设计成不占用太多空间，使其成为代表数据对象的理想选择。例如，一个哈希值可能代表一个客户，并包括 "姓名"、"地址"、"电子邮件 "或 "客户 ID "等字段。

本教程将介绍如何在 Redis 中管理哈希，包括创建哈希、检索和删除哈希散列中的数据。

如何使用这个教程

这个教程是以小抄（Cheat Sheet）的形式写的，有对应的例子。我们鼓励你直接跳转到和你要完成的任务相关的章节进行阅读。

创建哈希散列

要创建哈希散列，请运行 hset 命令。此命令接受哈希键的名称、字段字符串和相应的值字符串作为参数：

127.0.0.1:6379>  hset poet:Verlaine nationality French

注意：在这个例子中，poet:Verlaine 是这个散列的键。点、破折号、冒号通常用于使多字的键和字段更具有可读性。确保你的键遵循同一个易于阅读的规范对于数据维护很有帮助。

如果指定的字段是新字段并且值设置正确，则 hset 返回 (integer) 1：

输出

 (integer) 1

但是，如果你没有为哈希键包含值、字段或名称，“hset”将返回错误。

另外，请注意 hset 将覆盖已经存在的散列的内容。

127.0.0.1:6379>  hset poet:Verlaine nationality Francais

如果该字段已存在并且其值已成功更新，则 hset 将返回 (integer) 0：

输出

 (integer) 0

你还可以使用 hsetnx 将字段添加到哈希散列中，但它仅在该字段尚不存在时才有效。如果指定的字段已经存在，hsetnx 不会有任何作用，并且会返回 (integer) 0：

127.0.0.1:6379>  hsetnx poet:Verlaine nationality French

输出

 (integer) 0

要将多个字段/值对设置为给定集合，请使用 hmset 命令，后跟相应的字段/值字符串：

127.0.0.1:6379>  hmset poet:Verlaine born 1844 died 1896 genre Decadent

hmset 成功后将会返回一个 OK

从哈希散列中提取值

你可以使用 hexists 命令确定给定哈希散列是否存在字段：

127.0.0.1:6379>  hexists poet:Verlaine nationality

如果字段存在，hexists 将返回 (integer) 1，如果不存在，则返回 (integer) 0。

要返回字段的值，请运行 hget 命令，后跟哈希键和要检索其值的字段：

127.0.0.1:6379>  hget poet:Verlaine nationality

输出

 "Francais"

hmget 使用相同的语法，但可以返回多个字段的值

127.0.0.1:6379>  hmget poet:Verlaine born died

输出

 1) "1844"
 2) "1896"

如果你传递给 hget 或 hmget 的哈希值不存在，这两个命令都将返回 (nil)：

127.0.0.1:6379>  hmget poet:Dickinson born died

输出

 1) (nil)
 2) (nil)

要获取某个哈希散列中包含的所有字段的列表，请运行“hkeys”命令：

127.0.0.1:6379>  hkeys poet:Verlaine

输出

 1) "nationality"
 2) "born"
 3) "died"
 4) "genre"

相反，运行 hvals 来检索保存在哈希散列中的值列表：

127.0.0.1:6379>  hvals poet:Verlaine

输出

 1) "French"
 2) "1844"
 3) "1896"
 4) "Decadent"

要返回散列所包含的每个字段及其关联值的列表，请运行 hgetall：

127.0.0.1:6379>  hgetall poet:Verlaine

输出

 1) "nationality"
 2) "French"
 3) "born"
 4) "1844"
 5) "died"
 6) "1896"
 7) "genre"
 8) "Decadent"

你可以通过运行 hlen 来查找哈希散列中的字段数，它代表“hash length”:

127.0.0.1:6379>  hlen poet:Verlaine

输出

 (integer) 4

你可以使用hstrlen找到与字段关联的值字符串的长度，它代表“hash string length”:

127.0.0.1:6379>  hstrlen poet:Verlaine nationality

输出

 (integer) 8

如果哈希散列不存在，hlen 将返回 (integer) 0。

从哈希散列中移除字段

要从哈希散列中删除字段，请运行“hdel”命令。 hdel 可以接受多个字段作为参数，并将返回一个整数，指示从哈希散列中删除了多少字段：

127.0.0.1:6379>  hdel poet:Verlaine born died

输出

 (integer) 2

如果你将不存在的字段传递给 hdel，它将忽略该字段但删除你指定的任何其他现有字段。

总结

本指南详细介绍了一些用于在 Redis 中创建和管理哈希的命令。

如何管理 Redis 中的 Sets 集合

源地址：https://www.digitalocean.com/community/cheatsheets/how-to-manage-sets-in-redis
作者：Mark Drake

简介

Redis 是一个开源的、运行在内存中的键值数据库。Redis 中的 Sets 集合是存储在一个给定键上的字符串的集合。当存储在一个集合中时，一个单独的记录值被称为一个成员。与列表不同，集合是不允许重复值的无序结果。

本教程解释了如何创建集合，检索和删除成员，以及比较不同集合的成员。

如何使用这个教程

这个教程是以小抄（Cheat Sheet）的形式写的，有对应的例子。我们鼓励你直接跳转到和你要完成的任务相关的章节进行阅读。

创建集合

sadd 命令允许您创建一个集合并向其中添加一个或多个成员。以下示例将在名为 key_horror 的键上创建一个集合，其中包含成员 "Frankenstein" 和 "Godzilla"：

127.0.0.1:6379>  sadd key_horror "Frankenstein" "Godzilla"

sadd 如果成功，将返回一个整数，显示它添加到集合中的成员数：

输出

(integer) 2

如果您尝试将集合的成员添加到已经包含非集合值的键，它将返回错误。此块中的第一个命令创建一个名为 key_action 的 list，其中包含一个元素 "Shaft"。下一个命令尝试将集合成员 Shane 添加到列表中，但由于数据类型冲突，这会产生错误：

127.0.0.1:6379>  rpush key_action "Shaft"
127.0.0.1:6379>  sadd key_action "Shane"

输出

 (error) WRONGTYPE Operation against a key holding the wrong kind of value

请注意，集合不允许同一成员多次出现：

127.0.0.1:6379>  sadd key_comedy "It's" "A" "Mad" "Mad" "Mad" "Mad" "Mad" "World"

输出

 (integer) 4

即使这个 sadd 命令指定了 8 个成员，它也会丢弃 4 个重复的 "Mad" 成员，从而导致设置大小为 4。

从集合中提取成员

在本节中，我们将介绍一些 Redis 命令，这些命令返回有关集合中保存的成员的信息。要练习此处概述的命令，请运行以下命令，该命令将创建一个名为 key_stooges 的包含六个成员的集合：

127.0.0.1:6379>  sadd key_stooges "Moe" "Larry" "Curly" "Shemp" "Joe" "Curly Joe"

要返回集合中的每个成员，请运行smencer命令，后跟要检查的键：

127.0.0.1:6379>  smembers key_stooges

输出

1) "Curly"
2) "Moe"
3) "Larry"
4) "Shemp"
5) "Curly Joe"
6) "Joe"

要检查特定值是否是集合的成员，请使用 sismember 命令：

127.0.0.1:6379>  sismember key_stooges "Harpo"

如果元素 "Harpo" 是 key_stooges 集合的成员，则 sismember 将返回 1。否则，它将返回 0：

输出

 (integer) 0

希望查看给定集合中有多少成员（要查找给定集合的_cardinality_），请运行scard：

127.0.0.1:6379>  scard key_stooges

输出

 (integer) 6

希望从集合中获取一个随机元素，可以使用 srandmember 命令：

127.0.0.1:6379>  srandmember key_stooges

输出

 "Larry"

要从集合中返回多个随机的、不同的元素，您可以在 srandmember 命令之后使用要获取的元素数量：

127.0.0.1:6379>  srandmember key_stooges 3

输出

1) "Larry"
2) "Moe"
3) "Curly Joe"

如果给 srandmember 传负数作为参数，则允许该命令多次返回相同的元素：

127.0.0.1:6379>  srandmember key_stooges -3

输出

1) "Shemp"
2) "Curly Joe"
3) "Curly Joe"

虽然 srandmember 在大型数据集中的性能更好，但 srandmember 中使用的随机元素函数并不是完全随机的。有关详细信息，请参阅该命令的官方文档。

从集合中移除成员

Redis 带有三个用于从集合中删除成员的命令：spop、srem 和 smove。

spop 从集合中随机选择指定数量的成员并返回它们，类似于 srandmember，但同时会将它们从集合中删除。它接受集合的键名和要从集合中删除的成员数作为参数。如果您不指定数字，spop 将默认返回并删除单个值。

以下示例命令将从上一节中创建的 key_stooges 集中删除并返回两个随机选择的元素：

127.0.0.1:6379>  spop key_stooges 2

输出

1) "Shemp"
2) "Larry"

srem 允许您从集合中删除一个或多个特定成员，而不是随机的：

127.0.0.1:6379>  srem key_stooges "Joe" "Curly Joe"

srem 不是返回从集合中删除的成员，而是返回一个整数，显示删除了多少成员：

输出

 (integer) 2

使用 smove 将成员从一个集合移动到另一个集合。此命令按顺序接受源集、目标集和要移动的成员作为参数。请注意，smove 一次只允许您移动一个成员：

127.0.0.1:6379>  smove key_stooges key_jambands "Moe"

如果命令成功移动成员，它将返回 (integer) 1：

输出

 (integer) 1

如果 smove 失败，它将改为返回 (integer) 0。请注意，如果目标键不存在，smove 将创建后再移动成员。

对比集合

Redis 还提供了许多命令来查找集合之间的差异和相似之处。为了演示这些命令是如何工作的，本节将使用三个名为“presidents”、“kings”和“beatles”的集合。如果您想自己尝试本节中的命令，请使用如下 sadd 命令来创建。

127.0.0.1:6379>  sadd presidents "George" "John" "Thomas" "James"
127.0.0.1:6379>  sadd kings "Edward" "Henry" "John" "James" "George"
127.0.0.1:6379>  sadd beatles "John" "George" "Paul" "Ringo"

sinter 比较不同的集合并返回集合的交集，或出现在每个集合中的值：

127.0.0.1:6379>  sinter presidents kings beatles

输出

1) "John"
2) "George"

sinterstore 执行类似的功能，但不是返回相交的成员，而是在指定的目的地创建一个包含这些相交成员的新集合。请注意，如果目的地已经存在，sinterstore 将覆盖其内容：

127.0.0.1:6379>  sinterstore new_set presidents kings beatles
127.0.0.1:6379>  smembers new_set

输出

1) "John"
2) "George"

sdiff 返回 差异的集合 — 由以下每个集合与第一个指定集合的差异产生的成员：

127.0.0.1:6379>  sdiff presidents kings beatles

输出

 1) "Thomas"

换句话说，sdiff 查看第一个集合中的每个成员，然后将它们与每个后续集合中的成员进行比较。第一个集合中出现也在后续集合中出现的任何成员都将被删除，并且 sdiff 返回剩余的成员，将其视为从第一个集合中删除后续集合的成员。

sdiffstore 执行类似于 sdiff 的功能，但不是返回集合差异，而是在给定目的地创建一个包含了差异成员的新集合：

127.0.0.1:6379>  sdiffstore new_set beatles kings presidents
127.0.0.1:6379>  smembers new_set

输出

1) "Paul"
2) "Ringo"

与 sinterstore 一样，sdiffstore 将覆盖已存在的目标键。

sunion 返回 复合集合，或着说包含指定的每个集合的每个成员的新集合：

127.0.0.1:6379>  sunion presidents kings beatles

输出

1) "Thomas"
2) "George"
3) "Paul"
4) "Henry"
5) "James"
6) "Edward"
7) "John"
8) "Ringo"

sunion 将结果视为一个新集合，因为它只允许任何给定成员出现一次。

sunionstore 执行类似的功能，但在给定目的地创建一个包含集合并集的新集合，而不是仅返回结果：

127.0.0.1:6379>  sunionstore new_set presidents kings beatles

输出

 (integer) 8

与 sinterstore 和 sdiffstore 一样，sunionstore 将覆盖已经存在的集合。

总结

本指南详细介绍了一些用于在 Redis 中创建和管理集合的命令。

如何管理 Redis 中的 Sorted Sets 有序集合

源地址：https://www.digitalocean.com/community/cheatsheets/how-to-manage-sorted-sets-in-redis
作者：Mark Drake

简介

Redis 是一个开源的、运行在内存中的键值数据库。在 Redis 中，有序集合是一种与集合类似的数据类型，都是不重复的字符串组。不同的是，有序集的每个成员都与一个分数相关，允许它们从最小的分数到最大的分数进行排序或排名。

本教程解释了如何创建有序集，检索和删除其成员，以及基于现有的有序集创建新的有序集。

如何使用这个教程

这个教程是以小抄（Cheat Sheet）的形式写的，有对应的例子。我们鼓励你直接跳转到和你要完成的任务相关的章节进行阅读。

创建有序集合并添加成员

要创建有序集合，请使用 zadd 命令。 zadd 接受将保存有序集的键的名称作为参数，后跟要添加的成员的分数和成员本身的值。以下命令将创建一个名为 faveGuitarists 的有序集合键，其中一个成员为 "Joe Pass"，其得分为 1：

127.0.0.1:6379>  zadd faveGuitarists 1 "Joe Pass"

zadd 将返回一个整数，表示如果成功创建有序集，则将多少个成员添加到有序集中。

输出

 (integer) 1

您可以使用 zadd 将多个成员添加到有序集中。注意他们的分数不需要是连续的，分数之间可以有间隔，并且在同一个有序集中的多个成员可以使用相同的分数：

127.0.0.1:6379>  zadd faveGuitarists 4 "Stephen Malkmus" 2 "Rosetta Tharpe" 3 "Bola Sete" 3 "Doug Martsch" 8 "Elizabeth Cotten" 12 "Nancy Wilson" 4 "Memphis Minnie" 12 "Michael Houser"

输出

 (integer) 8

zadd 可以接受以下选项，您必须在键名之后和第一个成员分数之前输入：

NX 或 XX：这俩个选项互斥，在一次 zadd 操作当中，你只能选择一个：
- NX：告诉 zadd 不能更新现有成员。使用此选项，zadd 只会添加新元素。
- XX：告诉zadd只能更新现有元素。使用此选项，zadd 将永远不会添加新成员。
CH：zadd 默认只返回添加到有序集中的新元素的数量。但是，如果包含此选项，zadd 将返回数量为 changed 的元素。这包括新添加的成员和分数发生变化的成员。
INCR：增加对应成员的粉质。如果该成员尚不存在，该命令会将其添加到已排序的集合中，并以默认值 0 及增量作为其分数。在包含 INCR 的情况下，zadd 如果成功，将返回成员的新分数。需要注意的是，如果使用了这个选项，zadd 只能同时增加一个成员。

除了使用 zadd 和对应的 INCR 选项，你还可以使用 zincrby 命令来实现同样的行为。zincrby 根据输入的分数增加对应成员的分数，而不是像 zadd 一样设定对应的分数。例如，以下命令将成员“Stephen Malkmus”（最初为“4”）的得分增加“5”到“9”。

127.0.0.1:6379>  zincrby faveGuitarists 5 "Stephen Malkmus"

输出

"9"

与 zadd 命令的 INCR 选项一样，如果指定人员不存在，则 zincrby 将使用增量值作为其分数创建它。

从有序集合中提取成员

获取有序集中成员的最基本方法是使用 zrange 命令。这个命令接受要检索的有序集的键名，以及其中包含的成员的范围作为参数。该范围由从 0 开始的索引的两个数字定义，0 代表着集合中的第一个成员（或者分数最低的成员），1 代表下一个成员。

下面的这个示例展示了从 faveGuitarists 有序集中提取前四个成员：

127.0.0.1:6379>  zrange faveGuitarists 0 3

输出

1) "Joe Pass"
2) "Rosetta Tharpe"
3) "Bola Sete"
4) "Doug Martsch"

请注意，如果您传递给 zrange 的有序集有两个或多个共享相同分数的元素，它将按 字典序 或字母序对这些元素进行排序。

开始和停止索引也可以是负数，“-1”代表最后一个成员，“-2”代表倒数第二个，依此类推：

127.0.0.1:6379>  zrange faveGuitarists -5 -2

输出

1) "Memphis Minnie"
2) "Elizabeth Cotten"
3) "Stephen Malkmus"
4) "Michael Houser"

zrange 可以接受 WITHSCORES 参数，当包含该参数时，也会返回成员的分数：

127.0.0.1:6379>  zrange faveGuitarists 5 6 WITHSCORES

输出

1) "Elizabeth Cotten"
2) "8"
3) "Stephen Malkmus"
4) "9"

zrange 只能返回按数字升序排列的成员范围。如果希望按照降序返回成员范围必须使用 zrevrange 命令。你可以将这个命令看作在返回指定范围内的成员之前暂时反转给定有序集的顺序。因此，使用 zrevrange，0 将代表键中的 最后的成员，1 将代表倒数第二个，依此类推：

127.0.0.1:6379>  zrevrange faveGuitarists 0 5

输出

1) "Nancy Wilson"
2) "Michael Houser"
3) "Stephen Malkmus"
4) "Elizabeth Cotten"
5) "Memphis Minnie"
6) "Doug Martsch"

zrevrange 也接受 WITHSCORES 参数。

您可以使用 zrangebyscore 命令根据他们的分数返回一系列成员。在以下示例中，该命令将返回 faveGuitarists 键中的任何得分为 2、3 或 4 的成员：

127.0.0.1:6379>  zrangebyscore faveGuitarists 2 4

输出

1) "Rosetta Tharpe"
2) "Bola Sete"
3) "Doug Martsch"
4) "Memphis Minnie"

此示例中包含范围，这意味着它将返回得分为 2 或 4 的成员。您可以通过在范围的任一端加上左括号 (() 来排除范围的任何一端。以下示例将返回每个分数大于或等于“2”但小于“4”的成员：

127.0.0.1:6379>  zrangebyscore faveGuitarists 2 (4

输出

1) "Rosetta Tharpe"
2) "Bola Sete"
3) "Doug Martsch"

与 zrange 一样，zrangebyscore 可以接受 WITHSCORES 参数。它还接受 LIMIT 选项，您可以使用该选项仅从 zrangebyscore 输出中检索元素的选择。此选项接受一个 offset，它标记命令将返回的范围内的第一个成员，以及一个计数，它定义了多少个成员命令将全部返回。例如，以下命令将查看 faveGuitarists 有序集的前六个成员，但只会从中返回 3 个成员，从范围中的第二个成员开始，由 1 表示：

127.0.0.1:6379>  zrangebyscore faveGuitarists 0 5 LIMIT 1 3

输出

1) "Rosetta Tharpe"
2) "Bola Sete"
3) "Doug Martsch"

zrevrangebyscore 命令根据他们的分数返回一个反向的成员范围。以下命令返回分数在 10 到 6 之间的集合中的每个成员：

127.0.0.1:6379>  zrevrangebyscore faveGuitarists 10 6

输出

1) "Stephen Malkmus"
2) "Elizabeth Cotten"

与 zrangebyscore 一样，zrevrangebyscore 可以接受 WITHSCORES 和 LIMIT 选项。此外，您可以通过在其前面加上一个左括号来排除范围的任一端。

有时，有序集中的所有成员都具有相同的分数。在这种情况下，您可以使用 zrangebylex 命令强制 redis 返回按_字典顺序_或按字母顺序排序的一系列元素。要试用此命令，请运行以下 zadd 命令以创建一个有序集，其中每个成员具有相同的分数：

127.0.0.1:6379>  zadd SomervilleSquares 0 Davis 0 Inman 0 Union 0 porter 0 magoun 0 ball 0 assembly

zrangebylex 后面必须跟键名、开始间隔和停止间隔。开始和停止间隔必须以左括号 (() 或左括号 ([) 开头，如下所示：

127.0.0.1:6379>  zrangebylex SomervilleSquares [a [z

输出

1) "assembly"
2) "ball"
3) "magoun"
4) "porter"

请注意，此示例仅返回集合中八个成员中的四个，即使该命令查找从 a 到 z 的范围。这是因为 Redis 值区分大小写，因此以大写字母开头的成员被排除在其输出之外。要返回这些，您可以运行以下命令：

127.0.0.1:6379>  zrangebylex SomervilleSquares [A [z

输出

1) "Davis"
2) "Inman"
3) "Union"
4) "assembly"
5) "ball"
6) "magoun"
7) "porter"

zrangebylex 还接受特殊字符 -，表示负无穷，和 +，表示正无穷。因此，以下命令语法也将返回有序集的每个成员：

127.0.0.1:6379>  zrangebylex SomervilleSquares - +

请注意，zrangebylex 不能以相反的字典（字母升序）顺序返回已排序的集合成员。如果需要降序返回，需要使用 zrevrangebylex：

127.0.0.1:6379>  zrevrangebylex SomervilleSquares + -

输出

1) "porter"
2) "magoun"
3) "ball"
4) "assembly"
5) "Union"
6) "Inman"
7) "Davis"

因为它适用于每个成员具有相同分数的有序集，所以 zrangebylex 不支持 WITHSCORES 选项。但是，它确实支持 LIMIT 选项。

获取关于有序集的信息

要找出给定有序集中有多少成员（或者换句话说，要确定其 cardinality），请使用 zcard 命令。以下示例显示了本指南第一部分中的 faveGuitarists 键中有多少成员：

127.0.0.1:6379>  zcard faveGuitarists

输出

 (integer) 9

zcount 可以告诉您在给定的有序集中有多少元素在分数范围内。键后面的第一个数字是范围的开始，第二个是范围的结束：

127.0.0.1:6379>  zcount faveGuitarists 3 8

输出

 (integer) 4

zscore 输出有序集中指定成员的分数：

127.0.0.1:6379>  zscore faveGuitarists "Bola Sete"

输出

"3"

如果指定的成员或键不存在，zscore 将返回 (nil)。

zrank 类似于 zscore，但它不是返回给定成员的分数，而是返回其排名。在 Redis 中，rank 是有序集成员的从零开始的索引，按其分数排序。例如，"Joe Pass" 的得分为 1，但因为这是键中任何成员的最低得分，所以它的排名为 0：

127.0.0.1:6379>  zrank faveGuitarists "Joe Pass"

输出

 (integer) 0

还有另一个名为“zrevrank”的 Redis 命令，它执行与“zrank”相同的功能，但相反，它颠倒了集合中成员的排名。在以下示例中，成员“Joe Pass”的得分最低，因此反向排名最高：

127.0.0.1:6379>  zrevrank faveGuitarists "Joe Pass"

输出

 (integer) 8

成员的分数与其排名之间的唯一关系是他们的分数与其他成员的分数之间的关系。如果两个连续成员之间存在分数差距，则不会反映在他们的排名中。请注意，如果两个成员的分数相同，则按字母顺序排在第一位的成员排名较低。

与 zscore 一样，zrank 和 zrevrank 如果键或成员不存在，将返回 (nil)。

zlexcount 可以告诉您在一个字典范围之间的有序集中有多少成员。以下示例使用上一节中的“SomervilleSquares”有序集：

127.0.0.1:6379>  zlexcount SomervilleSquares [M [t

输出

 (integer) 5

该命令与 zrangebylex 命令的语法相同，因此请参阅上一节有关如何定义字符串范围的详细信息。

从有序集中移除成员

zrem 命令可以从有序集中删除一个或多个成员：

127.0.0.1:6379>  zrem faveGuitarists "Doug Martsch" "Bola Sete"

zrem 将返回一个整数，指示它从有序集中删除了多少成员：

输出

 (integer) 2

有三个 Redis 命令可让您根据范围删除已有序集的成员。例如，如果有序集中的每个成员具有相同的分数，您可以使用 zremrangebylex 根据词典范围删除成员。此命令使用与 zrangebylex 相同的语法。以下示例将从上一节中创建的 SomervilleSquares 键中删除所有以大写字母开头的成员：

127.0.0.1:6379>  zremrangebylex SomervilleSquares [A [Z

zremrangebylex 将输出一个整数，说明它删除了多少成员：

输出

 (integer) 3

您还可以使用 zremrangebyscore 命令根据分数范围删除成员，该命令使用与 zrangebyscore 命令相同的语法。以下示例将删除 faveGuitarists 中得分为 4、5 或 6 的每个成员：

127.0.0.1:6379>  zremrangebyscore faveGuitarists 4 6

输出

 (integer) 1

您可以使用 zremrangebyrank 命令根据一系列等级从集合中删除成员，该命令使用与 zrangebyrank 相同的语法。以下命令将删除有序集中具有最低排名的三个成员，这些成员由一系列从零开始的索引定义：

127.0.0.1:6379>  zremrangebyrank faveGuitarists 0 2

输出

 (integer) 3

请注意，传递给“zremrangebyrank”的数字也可以是负数，-1代表最高等级，-2代表下一个最高等级，依此类推。

从现有的有序集中创建一个新的有序集

Redis 包含两个命令，允许您比较多个有序集的成员并基于这些比较创建新的有序集：zinterstore 和zunionstore。要试验这些命令，请运行以下 zadd 命令来创建示例有序集。

127.0.0.1:6379>  zadd NewKids 1 "Jonathan" 2 "Jordan" 3 "Joey" 4 "Donnie" 5 "Danny"
127.0.0.1:6379>  zadd Nsync 1 "Justin" 2 "Chris" 3 "Joey" 4 "Lance" 5 "JC"

zinterstore 查找由两个或多个有序集共享的成员——它们的交集——并生成一个仅包含这些成员的新有序集。此命令必须按顺序包含相交成员将存储为有序集的目标键的名称、传递给“zinterstore”的键的数量以及您要分析的键的名称：

127.0.0.1:6379>  zinterstore BoyBands 2 NewKids Nsync

zinterstore 将返回一个整数，显示存储到目标有序集中的元素数量。因为 NewKids 和 Nsync 只共享一个成员，"Joey"，所以该命令将返回 1：

输出

 (integer) 1

请注意，zinterstore 将覆盖目标键内容。

zunionstore 将创建一个新的有序集，其中包含传递给它的键的每个成员。此命令使用与 zinterstore 相同的语法，并且需要目标键的名称、传递给命令的键的数量以及键的名称：

127.0.0.1:6379>  zunionstore SuperGroup 2 NewKids Nsync

与 zinterstore 一样，zunionstore 将返回一个整数，显示存储在目标键中的元素数量。尽管两个原始有序集都有五个成员，因为有序集不能有重复成员，并且每个键都有一个名为“Joey”的成员，所以结果整数将是“9”：

输出

 (integer) 9

与 zinterstore 一样，zunionstore 将覆盖已存在的目标键的内容。

为了让您在使用 zinterstore 和 zunionstore 创建新的有序集时更好地控制成员分数，这两个命令都接受 WEIGHTS 和 AGGREGATE 选项。

WEIGHTS 选项后跟一个数字，表示命令中包含的每个有序集，它_weight_ 或乘以每个成员的分数。 WEIGHTS 选项后的第一个数字加权传递给命令的第一个键的分数，第二个数字加权第二个键，依此类推。

下面的示例创建一个新的有序集，其中包含来自 NewKids 和 Nsync 有序集的相交键。它将“NewKids”键中的分数加权为 3 倍，并将“Nsync”键中的分数加权为 7 倍：

127.0.0.1:6379>  zinterstore BoyBandsWeighted 2 NewKids Nsync WEIGHTS 3 7

未指明 WEIGHTS 的情况下， zinterstore 和 zunionstore 的权重默认为 1。

AGGREGATE 接受三个子选项。其中第一个，SUM，通过在组合集中添加匹配成员的分数来实现 zinterstore 和 zunionstore 的默认行为。

如果您对共享一个成员的两个有序集运行 zinterstore 或 zunionstore 操作，但该成员在每个集合中具有不同的分数，则可以强制操作分配新集合中两个分数中较低的一个 MIN 子选项。

127.0.0.1:6379>  zinterstore BoyBandsWeightedMin 2 NewKids Nsync WEIGHTS 3 7 AGGREGATE MIN

因为这两个有序集只有一个匹配的成员具有相同的分数 (3)，所以此命令将创建一个新集，其中的成员具有两个加权分数中较低的一个：

127.0.0.1:6379>  zscore BoyBandsWeightedMin "Joey"

输出

"9"

同样，AGGREGATE 可以强制 zinterstore 或 zunionstore 使用 MAX 选项分配两个分数中的较高者：

127.0.0.1:6379>  zinterstore BoyBandsWeightedMax 2 NewKids Nsync WEIGHTS 3 7 AGGREGATE MAX

此命令创建一个包含一个成员“Joey”的新集合，该集合具有两个加权分数中的较高者：

127.0.0.1:6379>  zscore BoyBandsWeightedMax "Joey"

输出

 "21"

将 WEIGHTS 视为一种在分析之前临时操纵成员分数的方法会很有帮助。同样，将 AGGREGATE 选项视为一种在将成员添加到新集合之前决定如何控制成员分数的方法是有帮助的。

总结

本指南详细介绍了一些用于在 Redis 中创建和管理有序集的命令。

源地址：https://www.digitalocean.com/community/cheatsheets/how-to-run-transactions-in-redis
作者：Mark Drake

简介

Redis 是一个开源的、运行在内存中的键值数据库。Redis 允许你设计一连串的命令，并一个接一个地运行它们，这种程序被称为事务。客户端不可能在事务块执行时运行命令，这确保了事务被视为一个单独的隔离操作。

本教程介绍了如何执行和取消事务，还包括一些通常与事务有关的陷阱的信息。

如何使用这个教程

这个教程是以小抄（Cheat Sheet）的形式写的，有对应的例子。我们鼓励你直接跳转到和你要完成的任务相关的章节进行阅读。

运行事务

multi 命令告诉 Redis 开始一个事务块。任何后续命令都将进入队列，直到您运行 exec 命令，该命令将执行它们。

以下命令形成单个事务块。第一个命令启动事务，第二个设置一个 key 保存一个值为 1 的字符串，第三个将值增加 1，第四个将其值增加 40，第五个返回字符串的当前值，并且最后一个执行事务块：

127.0.0.1:6379>  multi
127.0.0.1:6379>  set key_MeaningOfLife 1
127.0.0.1:6379>  incr key_MeaningOfLife
127.0.0.1:6379>  incrby key_MeaningOfLife 40
127.0.0.1:6379>  get key_MeaningOfLife
127.0.0.1:6379>  exec

运行 multi 后，redis-cli 将使用 QUEUED 响应以下每个命令。运行 exec 命令后，它将分别显示每个命令的输出：

输出

1) OK
2) (integer) 2
3) (integer) 42
4) "42"

事务块中包含的命令按照它们排队的顺序依次运行。Redis 事务是原子化的，这意味着事务块中的每个命令都被会处理（意味着它被接受为有效并排队等待执行）或者没有。但是，即使命令成功排队，执行时仍可能产生错误。在这种情况下，事务中的其他命令仍然可以运行，但 Redis 会跳过导致错误的命令。更多信息参阅理解事务错误部分。

取消事务

想要取消一个事务，运行 discard 命令。它将阻止任何之前排队的命令运行：

127.0.0.1:6379>   multi
127.0.0.1:6379>  set key_A 146
127.0.0.1:6379>  incrby key_A 10
127.0.0.1:6379>  discard

输出

OK

discard 命令将连接返回到正常状态，这告诉 Redis 像往常一样运行单个命令。你需要再次运行multi来告诉服务器你正在开始另一个事务。

理解事务错误

某些命令可能无法排队，例如有语法错误的命令。如果您尝试将语法不正确的命令排队，Redis 将返回错误。

以下事务创建了一个名为“key_A”的键，然后尝试将其递增 10。但是，“incrby”命令中的拼写错误导致错误并关闭事务：

127.0.0.1:6379>  multi
127.0.0.1:6379>  set key_A 146
127.0.0.1:6379>  incrbuy key_A 10

输出

 (error) ERR unknown command 'incrbuy'

如果您在尝试将具有此类语法错误的命令排队后尝试运行“exec”命令，您将收到另一条错误消息，告诉您该事务已被丢弃：

127.0.0.1:6379>  exec

输出

 (error) EXECABORT Transaction discarded because of previous errors.

在这种情况下，您需要重新启动事务块并确保正确输入每个命令。

一些不可能的命令可能会排队，例如在只包含字符串的键上运行 incr。因为这样的命令在语法上是正确的，所以如果你尝试将它包含在事务中，Redis 不会返回错误，也不会阻止你运行 exec。在这种情况下，队列中的所有其他命令都将被执行，但不可能的命令将返回错误：

127.0.0.1:6379>  multi
127.0.0.1:6379>  set key_A 146
127.0.0.1:6379>  incrby key_A "ten"
127.0.0.1:6379>  exec

输出

1) OK
2) (error) ERR value is not an integer or out of range

有关 Redis 如何处理事务内部错误的更多信息，请参阅有关该主题的官方文档。

总结

本指南详细介绍了使用的一些命令在 Redis 中创建、运行和取消事务。

源地址：https://www.digitalocean.com/community/cheatsheets/how-to-expire-keys-in-redis
作者：Mark Drake

简介

Redis 是一个开源的、运行在内存中的键值数据库。Redis keys 默认是 persistent（持久化）的，意味着 Redis 服务器将会一直存储它们，除非它们被手动删除。然而，可能会有这样的情况：你设置了一个 key，但是你知道你会想在一段时间后删除它；换句话说，你想要一个 volatile（译者注：易挥发，这里指会过期）的 key。

本教程介绍了如何设置键值对过期、检查键值对过期的剩余时间以及取消键值对的过期设置。

如何使用这个教程

这个教程是以小抄（Cheat Sheet）的形式写的，有对应的例子。我们鼓励你直接跳转到和你要完成的任务相关的章节进行阅读。

设定 Key 的过期时间

您可以使用 expire 命令为现有键设置过期时间，该命令将密钥的名称和过期所需的秒数作为参数。你需要运行以下两个命令，第一个创建一个名为 key_melon 的字符串键，其值为 "cantaloupe"，第二个将其设置为在 450 秒后过期：

127.0.0.1:6379>  set key_melon "cantaloupe"
127.0.0.1:6379>   expire key_melon 450

如果超时设置成功，expire 命令将返回 (integer) 1。如果设置超时失败，它将改为返回 (integer) 0。

或者，您可以使用 expireat 命令将密钥设置为在特定时间点过期。它采用 Unix timestamp 作为参数，而不是到期前的秒数。Unix 时间戳是自 _Unix 纪元_或 1970 年 1 月 1 日 00:00:00 UTC 以来的秒数。有许多在线工具可用于查找特定日期和时间的 Unix 时间戳，例如 EpochConverter 或 UnixTimestamp.com。

例如，要将 key_melon 设置为 2025 年 5 月 1 日 GMT 时间晚上 8:30 到期（由 Unix 时间戳 1746131400 表示），您可以使用以下命令：

127.0.0.1:6379>  expireat key_melon 1746131400

请注意，如果您传递给 expireat 的时间戳已经发生，它将立即删除密钥。

检查键值对的过期时间

每当您将密钥设置为过期时，您都可以使用 ttl 检查过期的剩余时间（以秒为单位），它代表“time to live”:

127.0.0.1:6379>  ttl key_melon

输出

 (integer) 433

要获得更详细的信息，您可以运行 pttl，它将返回密钥过期前的时间量（以毫秒为单位）：

127.0.0.1:6379>  pttl key_melon

输出

 (integer) 431506

如果密钥未设置为过期，ttl 和 pttl 都将返回 (integer) -1，如果密钥不存在则返回 (integer) -2。

持久化键值对

如果键已设置为可过期，则任何覆盖键内容的命令（如set或 getset ）都将清除键的超时值。要手动清除密钥的超时，请使用 persist 命令：

127.0.0.1:6379>  persist key_melon

如果成功完成，persist 命令将返回 (integer) 1，表示密钥将不再过期。

总结

本指南详细介绍了一些用于在 Redis 中操作和检查密钥持久性的命令。

源地址：https://www.digitalocean.com/community/cheatsheets/how-to-troubleshoot-issues-in-redis
作者：Mark Drake

简介

Redis 是一个开源的、运行在内存中的键值数据库。Redis 自带几个命令，可以帮助解决和调试问题。由于 Redis 作为 [in-memory key-value store] (https://en.wikipedia.org/wiki/In-memory_database) 的性质，其中许多命令专注于内存管理，但还有其他一些命令可以帮助提供 Redis 服务器状态的概览。

本教程将详细介绍如何使用其中一些命令来帮助诊断和解决您在使用 Redis 时可能遇到的问题。

如何使用这个教程

这个教程是以小抄（Cheat Sheet）的形式写的，有对应的例子。我们鼓励你直接跳转到和你要完成的任务相关的章节进行阅读。

排查内存相关问题

memory usage 告诉你单个键当前使用了多少内存。它将键的名称作为参数并输出它使用的字节数：

127.0.0.1:6379>  memory usage key_meaningOfLife

输出

 (integer) 42

要更全面地了解 Redis 实例如何使用内存，可以运行“memory stats”命令：

127.0.0.1:6379>  memory stats

此命令输出一组与内存相关的指标及其值。以下是 memory stats 报告的指标：

peak.allocated: Redis 消耗的峰值字节数
total.allocated: Redis 分配的总字节数
startup.allocated: Redis 在启动时消耗的初始字节数
replication.backlog: 副本复制积压缓冲区的字节数
clients.slaves: 所有副本开销的总大小（输出和查询缓冲区以及连接上下文）
clients.normal: 所有客户端开销的总大小
aof.buffer: 当前 [append-only file]（https://en.wikipedia.org/wiki/Redis#Persistence）缓冲区的总大小
db.0: 服务器上使用的每个数据库的主字典和过期字典的开销，以字节为单位报告
overhead.total: 用于管理 Redis 键空间的所有开销的总和
keys.count: 服务器上所有数据库中存储的键总数
keys.bytes-per-key: 服务器的净内存使用量与 keys.count 的比率
dataset.bytes: 数据集的大小，以字节为单位
dataset.percentage: dataset.bytes 占用 Redis 的净内存使用百分比
peak.percentage: peak.allocated 占 total.allocated 的百分比
fragmentation: 当前使用的内存量除以 Redis 实际使用的物理内存的比值

memory malloc-stats 提供了来自 jemalloc 的内部统计报告，Redis 在 Linux 系统上使用的内存分配器：

127.0.0.1:6379>  memory malloc-stats

如果您似乎遇到了与内存相关的问题，但解析前面命令的输出证明没有帮助，您可以尝试运行 memory doctor：

127.0.0.1:6379>  memory doctor

此功能将输出它可以找到的任何内存消耗问题并建议潜在的解决方案。

获取你的 Redis 实例的基本信息

与内存管理没有直接关系的调试命令是monitor。此命令允许您查看 Redis 服务器处理的每个命令的处理流：

127.0.0.1:6379>  monitor

输出

OK
1566157213.896437 [0 127.0.0.1:47740] "auth" "foobared"
1566157215.870306 [0 127.0.0.1:47740] "set" "key_1" "878"

另一个对调试有用的命令是 info，它返回有关服务器的几个信息块和统计信息：

127.0.0.1:6379>  info

输出

# Server
redis_version:4.0.9
redis_git_sha1:00000000
redis_git_dirty:0
redis_build_id:9435c3c2879311f3
redis_mode:standalone
os:Linux 4.15.0-52-generic x86_64
. . .

该命令返回大量信息。如果您只想查看一个信息块，可以将其指定为 info 的参数：

127.0.0.1:6379>  info CPU

输出

# CPU
used_cpu_sys:173.16
used_cpu_user:70.89
used_cpu_sys_children:0.01
used_cpu_user_children:0.04

请注意，info 命令返回的信息取决于您使用的 Redis 版本。

使用 `keys` 命令

keys 命令在您忘记键名的情况下很有帮助，或者您可能创建了一个但不小心拼错了它的名称。 keys 查找匹配模式的键：

127.0.0.1:6379>  keys pattern

pattern 中可以使用如下符合 glob-style 模式的键：

? 是代表任何单个字符的通配符，所以 s?mmy 匹配 sammy、sommy 和 sqmmy
* 是一个通配符，代表任意数量的字符，包括不包含任何字符，所以 sa*y 匹配 sammy、say、sammmmmmy 和 salmony
您可以指定模式可以包含的两个或多个字符，方法是将它们括在括号中，因此 s[ai]mmy 将匹配 sammy 和 simmy，但不匹配 summy
要设置一个忽略一个或多个字母的通配符，请将它们括在括号中并在它们前面加上一个上箭头 (^)，因此 s[^oi]mmy 将匹配 sammy 和 sxmmy，但不匹配 sommy或simmy
要设置包含一系列字母的通配符，请用连字符分隔范围的开头和结尾并将其括在括号中，因此 s[a-o]mmy 将匹配 sammy、skmmy 和 sommy ，但不是 srmmy

警告： Redis 文档警告说，keys 几乎不应该在生产环境中使用，因为它会对性能产生重大负面影响。

总结

本指南详细介绍了许多有助于故障排除和解决使用 Redis 时可能遇到的问题的命令。

源地址：https://www.digitalocean.com/community/cheatsheets/how-to-change-redis-configuration
作者：Mark Drake

简介

Redis 是一个开源的、运行在内存中的键值数据库。 Redis 有几个命令可让您即时更改 Redis 服务器的配置设置。本教程将介绍其中一些命令，并解释如何使这些配置更改永久化。

如何使用这个教程

这个教程是以小抄（Cheat Sheet）的形式写的，有对应的例子。我们鼓励你直接跳转到和你要完成的任务相关的章节进行阅读。

请注意，代管的 Redis 数据库通常不允许用户更改配置文件。如果您使用 DigitalOcean 的代管数据库，本指南中使用的命令将导致错误。

修改 Redis 的配置

本节中概述的命令只会在当前会话期间改变 Redis 服务器的行为，或者直到您运行 config rewrite 这将使它们永久化。您可以通过使用默认文本编辑器打开和编辑 Redis 配置文件来直接更改这些配置。例如，您可以使用 nano 来执行此操作：

$  sudo nano /etc/redis/redis.conf

警告： config set 命令是非常危险的。修改你的 Redis 配置文件可能会导致 Redis 服务器出现意外或以无法预期的行为来运行。建议你只在测试环境或明确知道自己需要修改配置时使用 config set命令。

出于安全考虑，你可以选择将这些命令重命名为不容易被意外运行的命令。

config set 允许您在运行时重新配置 Redis，而无需重新启动服务。它使用以下语法：

127.0.0.1:6379>  config set parameter value

例如，如果您想更改 Redis 在运行 save 命令后将生成的数据库转储文件的名称，则可以运行如下命令：

127.0.0.1:6379>  config set "dbfilename" "new_file.rdb"

如果配置更改有效，该命令将返回 OK。否则会返回错误。

注意： 并非 redis.conf 文件中的每个参数都可以通过 config set 操作进行更改。例如，您不能更改 requirepass 参数定义的身份验证密码。

将配置修改持久化

config set 不会永久改变 Redis 实例的配置文件；它只会改变 Redis 在运行时的行为。要在运行 config-set 命令后编辑 redis.conf 并使当前会话的配置永久化，请运行 config rewrite：

127.0.0.1:6379>  config rewrite

此命令尽最大努力保留原始 redis.conf 文件的注释和整体结构，只需进行少量更改以匹配服务器当前使用的设置。

和 config set 一样，如果重写成功，config rewrite 会返回 OK。

检查 Redis 的配置

要读取 Redis 服务器的当前配置参数，请运行 config get 命令。 config get 接受一个参数，它可以是 redis.conf 中使用的参数的完全匹配，也可以是 glob 模式 . 例如：

127.0.0.1:6379>  config get repl*

根据您的 Redis 配置，此命令可能会返回：

输出

1) "repl-ping-slave-period"
2) "10"
3) "repl-timeout"
4) "60"
5) "repl-backlog-size"
6) "1048576"
7) "repl-backlog-ttl"
8) "3600"
9) "repl-diskless-sync-delay"
10) "5"
11) "repl-disable-tcp-nodelay"
12) "no"
13) "repl-diskless-sync"
14) "no"

您还可以通过运行 config get * 返回 config set 支持的所有配置参数。

总结

本指南详细介绍了用于动态更改 Redis 服务器配置文件的 redis-cli 命令。

如何管理 Redis 数据库 ｜ How To Manage a Redis Database

如何管理 Redis 数据库｜ How To Manage a Redis Database