From ff96f1cd0d082158295c0e7d14326f17b2c09efd Mon Sep 17 00:00:00 2001
From: Zhang Peng <forbreak@163.com>
Date: Mon, 11 Jun 2018 16:37:09 +0800
Subject: [PATCH] :memo: Writing docs.

---
 docs/redis/Redis事务.md    | 150 ++++++++++++++++++++++++++++
 docs/redis/Redis持久化.md | 184 +++++++++++++++++++++++++++++++++++
 2 files changed, 334 insertions(+)
 create mode 100644 docs/redis/Redis事务.md
 create mode 100644 docs/redis/Redis持久化.md

diff --git a/docs/redis/Redis事务.md b/docs/redis/Redis事务.md
new file mode 100644
index 0000000..fce25fe
--- /dev/null
+++ b/docs/redis/Redis事务.md
@@ -0,0 +1,150 @@
+---
+title: Redis 事务
+date: 2018/06/11
+categories:
+- database
+tags:
+- database
+- nosql
+- key-value
+- transaction
+---
+
+# Redis 事务
+
+<!-- TOC depthFrom:2 depthTo:3 -->
+
+- [事务简介](#事务简介)
+- [EXEC](#exec)
+- [MULTI](#multi)
+- [DISCARD](#discard)
+- [WATCH](#watch)
+    - [取消 WATCH 的场景](#取消-watch-的场景)
+    - [使用 WATCH 创建原子操作](#使用-watch-创建原子操作)
+- [Redis 不支持回滚](#redis-不支持回滚)
+- [Redis 脚本和事务](#redis-脚本和事务)
+- [资料](#资料)
+
+<!-- /TOC -->
+
+## 事务简介
+
+事务可以一次执行多个命令，并且有以下两个重要的保证：
+
+- 事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。
+- 事务是一个原子操作：事务中的命令要么全部被执行，要么全部都不执行。
+
+## EXEC
+
+**EXEC 命令负责触发并执行事务中的所有命令。**
+
+如果客户端在使用 MULTI 开启了一个事务之后，却因为断线而没有成功执行 EXEC ，那么事务中的所有命令都不会被执行。
+另一方面，如果客户端成功在开启事务之后执行 EXEC ，那么事务中的所有命令都会被执行。
+
+## MULTI
+
+**MULTI 命令用于开启一个事务，它总是返回 OK。**
+
+MULTI 执行之后，客户端可以继续向服务器发送任意多条命令，这些命令不会立即被执行，而是被放到一个队列中，当 EXEC 命令被调用时，所有队列中的命令才会被执行。
+
+以下是一个事务例子， 它原子地增加了 foo 和 bar 两个键的值：
+
+```py
+> MULTI
+OK
+> INCR foo
+QUEUED
+> INCR bar
+QUEUED
+> EXEC
+1) (integer) 1
+2) (integer) 1
+```
+
+## DISCARD
+
+**当执行 DISCARD 命令时，事务会被放弃，事务队列会被清空，并且客户端会从事务状态中退出。**
+
+示例：
+
+```py
+> SET foo 1
+OK
+> MULTI
+OK
+> INCR foo
+QUEUED
+> DISCARD
+OK
+> GET foo
+"1"
+```
+
+## WATCH
+
+WATCH 命令可以为 Redis 事务提供 check-and-set （CAS）行为。
+
+被 WATCH 的键会被监视，并会发觉这些键是否被改动过了。 如果有至少一个被监视的键在 EXEC 执行之前被修改了， 那么整个事务都会被取消， EXEC 返回 null 来表示事务已经失败。
+
+```
+WATCH mykey
+val = GET mykey
+val = val + 1
+MULTI
+SET mykey $val
+EXEC
+```
+
+使用上面的代码，如果在 WATCH 执行之后， EXEC 执行之前，有其他客户端修改了 mykey 的值，那么当前客户端的事务就会失败。程序需要做的，就是不断重试这个操作，直到没有发生碰撞为止。
+
+这种形式的锁被称作乐观锁，它是一种非常强大的锁机制。并且因为大多数情况下，不同的客户端会访问不同的键，碰撞的情况一般都很少，所以通常并不需要进行重试。
+
+**WATCH 使得 EXEC 命令需要有条件地执行：事务只能在所有被监视键都没有被修改的前提下执行，如果这个前提不能满足的话，事务就不会被执行。**
+
+WATCH 命令可以被调用多次。对键的监视从 WATCH 执行之后开始生效，直到调用 EXEC 为止。
+
+用户还可以在单个 WATCH 命令中监视任意多个键，例如：
+
+```py
+redis> WATCH key1 key2 key3
+OK
+```
+
+### 取消 WATCH 的场景
+
+当 EXEC 被调用时，不管事务是否成功执行，对所有键的监视都会被取消。
+
+另外，当客户端断开连接时，该客户端对键的监视也会被取消。
+
+使用无参数的 UNWATCH 命令可以手动取消对所有键的监视。对于一些需要改动多个键的事务，有时候程序需要同时对多个键进行加锁，然后检查这些键的当前值是否符合程序的要求。当值达不到要求时，就可以使用 UNWATCH 命令来取消目前对键的监视，中途放弃这个事务，并等待事务的下次尝试。
+
+### 使用 WATCH 创建原子操作
+
+WATCH 可以用于创建 Redis 没有内置的原子操作。
+
+举个例子，以下代码实现了原创的 ZPOP 命令，它可以原子地弹出有序集合中分值（score）最小的元素：
+
+```
+WATCH zset
+element = ZRANGE zset 0 0
+MULTI
+ZREM zset element
+EXEC
+```
+
+## Redis 不支持回滚
+
+Redis 不支持回滚的理由：
+
+- Redis 命令只会因为错误的语法而失败，或是命令用在了错误类型的键上面。
+- 因为不需要对回滚进行支持，所以 Redis 的内部可以保持简单且快速。
+
+## Redis 脚本和事务
+
+从定义上来说，Redis 中的脚本本身就是一种事务，所以任何在事务里可以完成的事，在脚本里面也能完成。并且一般来说，使用脚本要来得更简单，并且速度更快。
+
+## 资料
+
+- [Redis 官网](https://redis.io/)
+- [事务](http://redis.cn/topics/transactions.html)
+- [Redis 实战](https://item.jd.com/11791607.html)
diff --git a/docs/redis/Redis持久化.md b/docs/redis/Redis持久化.md
new file mode 100644
index 0000000..c100edb
--- /dev/null
+++ b/docs/redis/Redis持久化.md
@@ -0,0 +1,184 @@
+---
+title: Redis 持久化
+date: 2018/06/11
+categories:
+- database
+tags:
+- database
+- nosql
+- key-value
+---
+
+# Redis 持久化
+
+<!-- TOC depthFrom:2 depthTo:3 -->
+
+- [RDB](#rdb)
+    - [RDB 的原理](#rdb-的原理)
+    - [RDB 的配置](#rdb-的配置)
+    - [RDB 的优点](#rdb-的优点)
+    - [RDB 的缺点](#rdb-的缺点)
+- [AOF](#aof)
+    - [AOF 的原理](#aof-的原理)
+    - [AOF 的配置](#aof-的配置)
+    - [AOF 的优点](#aof-的优点)
+    - [AOF 的缺点](#aof-的缺点)
+- [选择持久化方式](#选择持久化方式)
+    - [怎样从 RDB 方式切换为 AOF 方式](#怎样从-rdb-方式切换为-aof-方式)
+    - [AOF 和 RDB 之间的相互作用](#aof-和-rdb-之间的相互作用)
+- [备份](#备份)
+    - [容灾备份](#容灾备份)
+- [资料](#资料)
+
+<!-- /TOC -->
+
+Redis 提供了两种持久方式：RDB 和 AOF。你可以同时开启两种持久化方式。在这种情况下, 当 redis 重启的时候会优先载入 AOF 文件来恢复原始的数据，因为在通常情况下 AOF 文件保存的数据集要比 RDB 文件保存的数据集要完整。
+
+## RDB
+
+RDB 持久化方式能够在指定的时间间隔能对整个数据进行快照存储。
+
+### RDB 的原理
+
+在默认情况下，Redis 将数据库快照保存在名字为 dump.rdb 的二进制文件中。你可以对 Redis 进行设置， 让它在“N 秒内数据集至少有 M 个改动”这一条件被满足时， 自动保存一次数据集。你也可以通过调用 SAVE 或者 BGSAVE，手动让 Redis 进行数据集保存操作。这种持久化方式被称为快照。
+
+当 Redis 需要保存 dump.rdb 文件时， 服务器执行以下操作:
+
+- Redis 创建一个子进程。
+- 子进程将数据集写入到一个临时 RDB 文件中。
+- 当子进程完成对新 RDB 文件的写入时，Redis 用新 RDB 文件替换原来的 RDB 文件，并删除旧的 RDB 文件。
+
+这种工作方式使得 Redis 可以从写时复制（copy-on-write）机制中获益。
+
+### RDB 的配置
+
+比如说， 在 redis.conf 中添加如下配置，表示让 Redis 在满足“ 60 秒内有至少有 1000 个键被改动”这一条件时， 自动保存一次数据集:
+
+```
+save 60 10000
+```
+
+### RDB 的优点
+
+- RDB 是一个非常紧凑的文件，它保存了某个时间点的数据集，非常适用于数据集的备份。比如你可以在每个小时报保存一下过去 24 小时内的数据，同时每天保存过去 30 天的数据，这样即使出了问题你也可以根据需求恢复到不同版本的数据集。
+- RDB 是一个紧凑的单一文件，很方便传送到另一个远端数据中心或者亚马逊的 S3（可能加密），非常适用于灾难恢复。
+- RDB 在保存 RDB 文件时父进程唯一需要做的就是 fork 出一个子进程，接下来的工作全部由子进程来做，父进程不需要再做其他 IO 操作，所以 RDB 持久化方式可以最大化 redis 的性能。
+- 与 AOF 相比，在恢复大的数据集的时候，DB 方式会更快一些。
+
+### RDB 的缺点
+
+- 如果你希望在 redis 意外停止工作（例如电源中断）的情况下丢失的数据最少的话，那么 RDB 不适合你。虽然你可以配置不同的 save 时间点(例如每隔 5 分钟并且对数据集有 100 个写的操作)，是 Redis 要完整的保存整个数据集是一个比较繁重的工作，你通常会每隔 5 分钟或者更久做一次完整的保存，万一在 Redis 意外宕机，你可能会丢失几分钟的数据。
+- RDB 需要经常 fork 子进程来保存数据集到硬盘上。当数据集比较大的时候，fork 的过程是非常耗时的，可能会导致 Redis 在一些毫秒级内不能响应客户端的请求。如果数据集巨大并且 CPU 性能不是很好的情况下，这种情况会持续 1 秒。AOF 也需要 fork，但是你可以调节重写日志文件的频率来提高数据集的耐久度。
+
+## AOF
+
+AOF 持久化方式记录每次对服务器执行的写操作。当服务器重启的时候会重新执行这些命令来恢复原始的数据。
+
+AOF 命令以 redis 协议追加保存每次写的操作到文件末尾。Redis 还能对 AOF 文件进行后台重写。使得 AOF 文件的体积不至于过大。
+
+### AOF 的原理
+
+- Redis 创建一个子进程。
+- 子进程开始将新 AOF 文件的内容写入到临时文件。
+- 对于所有新执行的写入命令，父进程一边将它们累积到一个内存缓存中，一边将这些改动追加到现有 AOF 文件的末尾，这样样即使在重写的中途发生停机，现有的 AOF 文件也还是安全的。
+- 当子进程完成重写工作时，它给父进程发送一个信号，父进程在接收到信号之后，将内存缓存中的所有数据追加到新 AOF 文件的末尾。
+- 搞定！现在 Redis 原子地用新文件替换旧文件，之后所有命令都会直接追加到新 AOF 文件的末尾。
+
+### AOF 的配置
+
+在 redis.conf 中打开 AOF 的方式（默认是不打开的）：
+
+```
+appendonly yes
+```
+
+从现在开始， 每当 Redis 执行一个改变数据集的命令时（比如 SET），这个命令就会被追加到 AOF 文件的末尾。这样的话，当 Redis 重新启时，程序就可以通过重新执行 AOF 文件中的命令来达到重建数据集的目的。
+
+#### 追加 AOF 策略
+
+Redis 多久才将数据 fsync 到磁盘一次，有三种策略：
+
+- appendfsync always：每次有新命令追加到 AOF 文件时就执行一次 fsync。非常慢，也非常安全。
+- appendfsync everysec：每秒 fsync 一次。足够快（和使用 RDB 持久化差不多），并且在故障时只会丢失 1 秒钟的数据。
+- appendfsync no：从不 fsync。将数据交给操作系统来处理。更快，也更不安全的选择。
+- 推荐（并且也是默认）的措施为每秒 fsync 一次， 这种 fsync 策略可以兼顾速度和安全性。
+
+### AOF 的优点
+
+- 使用 AOF 会让你的 Redis 更加耐久: 你可以使用不同的 fsync 策略：无 fsync；每秒 fsync；每次写的时候 fsync。使用默认的每秒 fsync 策略，Redis 的性能依然很好(fsync 是由后台线程进行处理的,主线程会尽力处理客户端请求)，一旦出现故障，你最多丢失 1 秒的数据。
+- AOF 文件是一个只进行追加的日志文件，所以不需要写入 seek，即使由于某些原因(磁盘空间已满，写的过程中宕机等等)未执行完整的写入命令，你也也可使用 redis-check-aof 工具修复这些问题。
+- Redis 可以在 AOF 文件体积变得过大时，自动地在后台对 AOF 进行重写：重写后的新 AOF 文件包含了恢复当前数据集所需的最小命令集合。整个重写操作是绝对安全的，因为 Redis 在创建新 AOF 文件的过程中，会继续将命令追加到现有的 AOF 文件里面，即使重写过程中发生停机，现有的 AOF 文件也不会丢失。而一旦新 AOF 文件创建完毕，Redis 就会从旧 AOF 文件切换到新 AOF 文件，并开始对新 AOF 文件进行追加操作。
+- AOF 文件有序地保存了对数据库执行的所有写入操作，这些写入操作以 Redis 协议的格式保存。因此 AOF 文件的内容非常容易被人读懂，对文件进行分析（parse）也很轻松。 导出（export） AOF 文件也非常简单。举个例子，如果你不小心执行了 FLUSHALL 命令，但只要 AOF 文件未被重写，那么只要停止服务器，移除 AOF 文件末尾的 FLUSHALL 命令，并重启 Redis ，就可以将数据集恢复到 FLUSHALL 执行之前的状态。
+
+### AOF 的缺点
+
+- 对于相同的数据集来说，AOF 文件的体积通常要大于 RDB 文件的体积。
+- 根据所使用的 fsync 策略，AOF 的速度可能会慢于 RDB 。在一般情况下，每秒 fsync 的性能依然非常高，而关闭 fsync 可以让 AOF 的速度和 RDB 一样快，即使在高负荷之下也是如此。不过在处理巨大的写入载入时，RDB 可以提供更有保证的最大延迟时间（latency）。
+
+## 选择持久化方式
+
+如果你只希望你的数据在服务器运行的时候存在，你可以不使用任何持久化方式。
+
+如果你非常关心你的数据，但仍然可以承受数分钟以内的数据丢失，那么你可以只使用 RDB 持久化。
+
+如果你不能承受数分钟以内的数据丢失，那么你可以同时使用 RDB 持久化和 AOF 持久化。
+
+有很多用户都只使用 AOF 持久化， 但我们并不推荐这种方式： 因为定时生成 RDB 快照（snapshot）非常便于进行数据库备份，并且 RDB 恢复数据集的速度也要比 AOF 恢复的速度要快，除此之外，使用 RDB 还可以避免之前提到的 AOF 程序的 bug 。
+
+### 怎样从 RDB 方式切换为 AOF 方式
+
+在 Redis 2.2 或以上版本，可以在不重启的情况下，从 RDB 切换到 AOF ：
+
+- 为最新的 dump.rdb 文件创建一个备份。
+- 将备份放到一个安全的地方。
+- 执行以下两条命令:
+- redis-cli config set appendonly yes
+- redis-cli config set save “”
+- 确保写命令会被正确地追加到 AOF 文件的末尾。
+- 执行的第一条命令开启了 AOF 功能： Redis 会阻塞直到初始 AOF 文件创建完成为止， 之后 Redis 会继续处理命令请求， 并开始将写入命令追加到 AOF 文件末尾。
+
+执行的第二条命令用于关闭 RDB 功能。 这一步是可选的， 如果你愿意的话， 也可以同时使用 RDB 和 AOF 这两种持久化功能。
+
+重要:别忘了在 redis.conf 中打开 AOF 功能！ 否则的话， 服务器重启之后， 之前通过 CONFIG SET 设置的配置就会被遗忘， 程序会按原来的配置来启动服务器。
+
+### AOF 和 RDB 之间的相互作用
+
+在版本号大于等于 2.4 的 Redis 中， BGSAVE 执行的过程中， 不可以执行 BGREWRITEAOF 。 反过来说， 在 BGREWRITEAOF 执行的过程中， 也不可以执行 BGSAVE。这可以防止两个 Redis 后台进程同时对磁盘进行大量的 I/O 操作。
+
+如果 BGSAVE 正在执行， 并且用户显示地调用 BGREWRITEAOF 命令， 那么服务器将向用户回复一个 OK 状态， 并告知用户， BGREWRITEAOF 已经被预定执行： 一旦 BGSAVE 执行完毕， BGREWRITEAOF 就会正式开始。 当 Redis 启动时， 如果 RDB 持久化和 AOF 持久化都被打开了， 那么程序会优先使用 AOF 文件来恢复数据集， 因为 AOF 文件所保存的数据通常是最完整的。
+
+## 备份
+
+**务必确保你的数据有完整的备份。**
+
+磁盘故障、节点失效，诸如此类的问题都可能让你的数据消失不见，不进行备份是非常危险的。
+
+备份 Redis 数据建议采用如下策略：
+
+备份 Redis 数据建议采用 RDB 方式。RDB 文件一旦创建，就不会进行任何修改，所以十分安全。
+
+Redis RDB 备份过程：
+
+- 创建一个定期任务（cron job），每小时将一个 RDB 文件备份到一个文件夹，并且每天将一个 RDB 文件备份到另一个文件夹。
+- 确保快照的备份都带有相应的日期和时间信息，每次执行定期任务脚本时，使用 find 命令来删除过期的快照：比如说，你可以保留最近 48 小时内的每小时快照，还可以保留最近一两个月的每日快照。
+- 至少每天一次，将 RDB 备份到你的数据中心之外，或者至少是备份到你运行 Redis 服务器的物理机器之外。
+
+### 容灾备份
+
+Redis 的容灾备份基本上就是对数据进行备份，并将这些备份传送到多个不同的外部数据中心。
+
+容灾备份可以在 Redis 运行并产生快照的主数据中心发生严重的问题时，仍然让数据处于安全状态。
+
+以下是一些实用的容灾备份方法：
+
+- Amazon S3 ，以及其他类似 S3 的服务，是一个构建灾难备份系统的好地方。 最简单的方法就是将你的每小时或者每日 RDB 备份加密并传送到 S3 。对数据的加密可以通过 gpg -c 命令来完成（对称加密模式）。记得把你的密码放到几个不同的、安全的地方去（比如你可以把密码复制给你组织里最重要的人物）。同时使用多个储存服务来保存数据文件，可以提升数据的安全性。
+- 传送快照可以使用 SCP 来完成（SSH 的组件）。 以下是简单并且安全的传送方法： 买一个离你的数据中心非常远的 VPS ，装上 SSH ，创建一个无口令的 SSH 客户端 key ，并将这个 key 添加到 VPS 的 authorized_keys 文件中，这样就可以向这个 VPS 传送快照备份文件了。为了达到最好的数据安全性，至少要从两个不同的提供商那里各购买一个 VPS 来进行数据容灾备份。
+- 需要注意的是，这类容灾系统如果没有小心地进行处理的话，是很容易失效的。最低限度下，你应该在文件传送完毕之后，检查所传送备份文件的体积和原始快照文件的体积是否相同。如果你使用的是 VPS ，那么还可以通过比对文件的 SHA1 校验和来确认文件是否传送完整。
+
+另外， 你还需要一个独立的警报系统， 让它在负责传送备份文件的传送器（transfer）失灵时通知你。
+
+## 资料
+
+- [Redis 官网](https://redis.io/)
+- [Redis 实战](https://item.jd.com/11791607.html)
+- [Redis Persistence](https://redis.io/topics/persistence)