企业级 NoSQL 数据库 Redis

← 上一章：高可用集群 KEEPALIVED ｜ 返回总目录 ｜ 下一章：文档数据库 MongoDB →

内容概述

NoSQL 和 Redis 特性

• Redis 部署

• Redis 使用

• Redis 数据类型

• Redis 主从复制

• Redis Sentinel

Redis Cluster

1 Redis 部署

1.1 Redis 基础

1.1.1 NoSQL 数据库

1.1.1.1 什么是 NoSQL

数据库主要分为两大类：关系型数据库与 NoSQL 数据库。

关系型数据库，是建立在关系模型基础上的数据库，其借助于集合代数等数学概念和方法来处理数据库中的数据。主流的 MySQL、Oracle、MS SQL Server 和 DB2 都属于这类传统数据库。

NoSQL 数据库，全称为 Not Only SQL，意思就是适用关系型数据库的时候就使用关系型数据库，不适用的时候可以考虑使用更加合适的数据存储。NoSQL 是对不同于传统的关系型数据库的数据库管理系统的统称。

NoSQL用于超大规模数据的存储。（例如谷歌或Facebook每天为他们的用户收集万亿比特的数据）。 这些类型的数据存储不需要固定的模式，无需多余操作就可以横向扩展。

1.1.1.2 NoSQL 起源

NoSQL一词最早出现于1998年，是Carlo Strozzi开发的一个轻量、开源、不提供SQL功能的关系数据库。

2009年，Last.fm的Johan Oskarsson发起了一次关于分布式开源数据库的讨论，来自Rackspace的Eric Evans再次提出了NoSQL的概念，这时的NoSQL主要指非关系型、分布式、不提供ACID的数据库设计模式。

2009年在亚特兰大举行的"no:sql(east)"讨论会是一个里程碑，其口号是"select fun, profit from real_world where relational=false;"。因此，对NoSQL最普遍的解释是"非关联型的"，强调Key-Value Stores和文档数据库的优点，而不是单纯的反对RDBMS。

1.1.1.3 为什么使用NoSQL

Oracle，MySQL 等传统的关系数据库非常成熟并且已大规模商用，为什么还要用 NoSQL 数据库呢？

主要是由于随着互联网发展，数据量越来越大，对性能要求越来越高，传统数据库存在着先天性的缺陷，即单机（单库）性能瓶颈，并且扩展困难。这样既有单机单库瓶颈，却又扩展困难，自然无法满足日益增长的海量数据存储及其性能要求，所以才会出现了各种不同的 NoSQL 产品，NoSQL 根本性的优势在于在云计算时代，简单、易于大规模分布式扩展，并且读写性能非常高

通过第三方平台（如：Google,Facebook等）可以很容易的访问和抓取数据。用户的个人信息，社交网络，地理位置，用户生成的数据和用户操作日志已经成倍的增加。如果要对这些用户数据进行挖掘，那 SQL数据库已经不适合这些应用了, NoSQL 数据库的发展却能很好的处理这些大的数据。

1.1.1.5 RDBMS和NOSQL对比

RDBMS

高度组织化结构化数据结构化查询语言（SQL） 数据和关系都存储在单独的表中。

数据操纵语言，数据定义语言严格的一致性基础事务

NoSQL

代表着不仅仅是SQL, 没有声明性查询语言

• 没有预定义的模式

• 最终一致性，而非ACID属性

• 非结构化和不可预知的数据

• CAP定理

高性能，高可用性和可伸缩性

1.1.1.6 NoSQL的优点/缺点

1.1.1.6 CAP定理（CAP theorem）

在计算机科学中, CAP定理（CAP theorem）, 又被称为布鲁尔定理（Brewer's theorem）, 它指出对于一个分布式计算系统来说，不可能同时满足以下三点:

• 一致性(Consistency) :所有节点在同一时间具有相同的数据

• 可用性(Availability) :保证每个请求不管成功或者失败都有响应 分区容忍(Partition tolerance) :系统中任意信息的丢失或失败不会影响系统的继续运作

CAP理论的核心是：一个分布式系统不可能同时很好的满足一致性，可用性和分区容错性这三个需求， 最多只能同时较好的满足两个。

因此，根据 CAP 原理将 NoSQL 数据库分成了满足 CA 原则、满足 CP 原则和满足 AP 原则三大类：

CA - 单点集群，满足一致性，可用性的系统，通常在可扩展性上不太强大。

CP - 满足一致性，分区容忍性的系统，通常性能不是特别高。 AP - 满足可用性，分区容忍性的系统，通常可能对一致性要求低一些。

1.1.1.7 NoSQL 数据库分类

1.1.2 Redis 简介

Redis (Remote Dictionary Server远程字典服务)是一个遵循BSD MIT开源协议的高性能的NoSQL.Redis 基于ANSI C语言语言)编写的key-value数据库,是意大利的Salvatore Sanfilippo在2009年发布，从2010 年3月15日起，Redis的开发工作由VMware主持。从2013年5月开始，Redis的开发由Pivotal公司赞助。 目前国内外使用的公司众多,比如:阿里,腾讯,百度,京东,新浪微博,GitHub,Twitter 等

Redis的出现，很大程度补偿了memcached这类key/value存储的不足，在部分场合可以对关系数据库起到很好的补充作用。它提供了Java，C/C++，Go, C#，PHP，JavaScript，Perl，Object-C，Python， Ruby，Erlang等客户端

DB-Engine月度排行榜Redis在键值型存储类的数据库长期居于首位,远远高于第二位的memcached

https://db-engines.com/en/ranking

Redis 官网地址：https://redis.io/

1.1.3 Redis 特性

速度快: 10W QPS,基于内存,C语言实现

• 单线程

• 持久化

• 支持多种数据结构支持多种编程语言

功能丰富: 支持Lua脚本,发布订阅,事务,pipeline等功能

• 简单: 代码短小精悍(单机核心代码只有23000行左右),单线程开发容易,不依赖外部库,使用简单主从复制

• 支持高可用和分布式

1.1.4 单线程

Redis 6.0版本前一直是单线程方式处理用户的请求

单线程为何如此快?

• 纯内存

• 非阻塞

• 避免线程切换和竞态消耗

注意事项:

• 一次只运行一条命令

• 避免执行长(慢)命令:keys *, flushall, flushdb, slow lua script, mutil/exec, operate big value(collection)

• 其实不是单线程: 早期版本是单进程单线程,3.0 版本后实际还有其它的线程, 实现特定功能,如: fysnc file descriptor,close file descriptor

1.1.5 Redis 对比 Memcached

1.1.6 Redis 常见应用场景

• 缓存：缓存RDBMS中数据,比如网站的查询结果、商品信息、微博、新闻、消息

• Session 共享：实现Web集群中的多服务器间的session共享

• 计数器：商品访问排行榜、浏览数、粉丝数、关注、点赞、评论等和次数相关的数值统计场景

• 社交：朋友圈、共同好友、可能认识他们等

• 地理位置: 基于地理信息系统GIS（Geographic Information System)实现摇一摇、附近的人、外卖等功能

• 消息队列：ELK等日志系统缓存、业务的订阅/发布系统

1.1.7 缓存的实现流程

数据更新操作流程：

数据读操作流程：

1.1.8 缓存穿透,缓存击穿和缓存雪崩

1.1.8.1 缓存穿透

缓存穿透是指缓存和数据库中都没有的数据，而用户不断发起请求，比如： 发起为id为 “-1” 的数据或id 为特别大不存在的数据。这时的用户很可能是攻击者，攻击会导致数据库压力过大。

解决方法：

• 接口层增加校验，如用户鉴权校验，id做基础校验，id<=0的直接拦截

• 从缓存取不到的数据，在数据库中也没有取到，这时也可以将key-value对写为key-null，缓存有效时间可以设置短点，如30秒（设置太长会导致正常情况也没法使用）。这样可以防止攻击用户反复用同一个id暴力攻击

1.1.8.2 缓存击穿

缓存击穿是指缓存中没有但数据库中有的数据，比如：热点数据的缓存时间到期后，这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压力

解决方法：

设置热点数据永远不过期。

1.1.8.3 缓存雪崩

缓存雪崩是指缓存中数据大批量到过期时间，而查询数据量巨大，引起数据库压力过大甚至down机。和缓存击穿不同的是，缓存击穿指并发查同一条数据，缓存雪崩是不同数据都过期了，很多数据都查不到从而查数据库。

解决方法：

• 缓存数据的过期时间设置随机，防止同一时间大量数据过期现象发生如果缓存数据库是分布式部署，将热点数据均匀分布在不同搞得缓存数据库中设置热点数据永远不过期

1.2 Redis 安装及连接

官方下载地址：

http://download.redis.io/releases/

1.2.1 包安装 Redis

1.2.1.1 Ubuntu 安装 Redis

[root@ubuntu2204 ~]#apt list redis
正在列表... 完成
redis/jammy 5:6.0.16-1ubuntu1 all
[root@ubuntu2004 ~]#apt list redis
正在列表... 完成
redis/focal-security,focal-updates 5:5.0.7-2ubuntu0.1 all
N: 还有1个版本。请使用-a选项来查看它(他们)。
[root@ubuntu2004 ~]#apt -y install redis
[root@ubuntu2004 ~]#pstree -p|grep redis
           |-redis-server(1330)-+-{redis-server}(1331)
           |                    |-{redis-server}(1332)
           |                    `-{redis-server}(1333)
[root@ubuntu2004 ~]#ss -ntll
State            Recv-Q   Send-Q     Local Address:Port    Peer Address:Port
      Process
LISTEN           0128127.0.0.1:6010         0.0.0.0:*
LISTEN           0511127.0.0.1:6379         0.0.0.0:*
LISTEN           04096127.0.0.53%lo:53           0.0.0.0:*
LISTEN           01280.0.0.0:22           0.0.0.0:*
LISTEN           0128                [::1]:6010            [::]:*
LISTEN           0511                [::1]:6379            [::]:*
LISTEN           0128                 [::]:22              [::]:*

1.2.1.2 CentOS 安装 Redis

#CentOS 8 由系统源提供
[root@centos8 ~]#dnf info redis
Name         : redis
Version      : 5.0.3
Release      : 1.module_el8.0.0+6+ab019c03
Architecture : x86_64
Size         : 927 k
Source       : redis-5.0.3-1.module_el8.0.0+6+ab019c03.src.rpm
Repository   : AppStream
Summary      : A persistent key-value database
URL          : http://redis.io
License      : BSD and MIT
Description  : Redis is an advanced key-value store. It is often referred to as a
data
             : structure server since keys can contain strings, hashes, lists,
sets and
             : sorted sets.
             :

            : In order to achieve its outstanding performance, Redis works with
an
            : in-memory dataset. Depending on your use case, you can persist it
either
            : by dumping the dataset to disk every once in a while, or by
appending
            : each command to a log.
            :
            : Redis also supports trivial-to-setup master-slave replication, with
very
            : fast non-blocking first synchronization, auto-reconnection on net
split
            : and so forth.
            :
            : Other features include Transactions, Pub/Sub, Lua scripting, Keys
with a
            : limited time-to-live, and configuration settings to make Redis
behave like
            : a cache.
            :
            : You can use Redis from most programming languages also.

[root@centos8 ~]#dnf -y install redis
[root@centos8 ~]#systemctl enable --now redis

[root@centos8 ~]#ss -tnl
State        Recv-Q        Send-Q        Local Address:Port            Peer
Address:Port
LISTEN       01280.0.0.0:22
0.0.0.0:*
LISTEN       0128127.0.0.1:6379
0.0.0.0:*
LISTEN       0128                    [::]:22
[::]:*

[root@centos8 ~]#pstree -p|grep redis
           |-redis-server(3383)-+-{redis-server}(3384)
           |                    |-{redis-server}(3385)
           |                    `-{redis-server}(3386)
[root@centos8 ~]#redis-cli
127.0.0.1:6379> ping
PONG
127.0.0.1:6379> info
# Server
redis_version:5.0.3
redis_git_sha1:00000000
redis_git_dirty:0
redis_build_id:8c0bf22bfba82c8f
redis_mode:standalone
os:Linux 4.18.0-147.el8.x86_64 x86_64

1.2.2 编译安装 Redis

Redis 源码包官方下载链接：

http://download.redis.io/releases/

1.2.2.1 编译安装

官方的安装方法：

https://redis.io/download

范例: 编译安装

#安装依赖包

[root@centos8~]#yum -y install gcc make  jemalloc-devel

#如果支持systemd需要安装下面包
[root@centos8~]#yum  -y install gcc jemalloc-devel systemd-devel
[root@ubuntu2004 ~]#apt -y install make gcc libjemalloc-dev libsystemd-dev

#下载源码
[root@centos8 ~]#wget http://download.redis.io/releases/redis-6.2.4.tar.gz
[root@centos8 ~]#tar xvf redis-6.2.4.tar.gz

#编译安装
[root@centos8 ~]#cd redis-6.2.4/
[root@centos8 redis-6.2.4]#make -j 2 PREFIX=/apps/redis install #指定redis安装目录
#如果支持systemd,需要执行下面
[root@centos8 redis-6.2.4]#make -j 2  USE_SYSTEMD=yes  PREFIX=/apps/redis
install

#配置环境变量
[root@centos8 ~]#echo 'PATH=/apps/redis/bin:$PATH' > /etc/profile.d/redis.sh
[root@centos8 ~]#. /etc/profile.d/redis.sh

#目录结构
[root@centos8 ~]#tree /apps/redis/
/apps/redis/
└── bin
    ├── redis-benchmark
    ├── redis-check-aof
    ├── redis-check-rdb
    ├── redis-cli
    ├── redis-sentinel -> redis-server
    └── redis-server
1 directory, 6 files

# 准备相关目录和配置文件

[root@centos8 ~]#mkdir /apps/redis/{etc,log,data,run} #创建配置文件、日志、数据等目录
[root@centos8 redis-6.2.4]#cp redis.conf /apps/redis/etc/

1.2.2.2 前台启动 Redis

redis-server 是 redis 服务器端的主程序

[root@centos8 ~]#redis-server  --help
Usage: ./redis-server [/path/to/redis.conf] [options]
       ./redis-server - (read config from stdin)
       ./redis-server -v or --version
       ./redis-server -h or --help
       ./redis-server --test-memory <megabytes>
Examples:
       ./redis-server (run the server with default conf)
       ./redis-server /etc/redis/6379.conf
       ./redis-server --port7777
       ./redis-server --port7777--slaveof127.0.0.1 8888
       ./redis-server /etc/myredis.conf --loglevel verbose
Sentinel mode:
       ./redis-server /etc/sentinel.conf --sentinel

前台启动 redis

[root@centos8 ~]#redis-server  /apps/redis/etc/redis.conf
27569:C 16 Feb 202021:18:20.412 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
27569:C 16 Feb 202021:18:20.412 # Redis version=5.0.7, bits=64,
commit=00000000, modified=0, pid=27569, just started
27569:C 16 Feb 202021:18:20.412 # Configuration loaded
27569:M 16 Feb 202021:18:20.413 * Increased maximum number of open files to
10032 (it was originally set to 1024).

                _._
           _.-``__ ''-._
      _.-```.  `_.  ''-._           Redis 5.0.7 (00000000/0) 64 bit
  .-`` .-```.  ```\/    _.,_ ''-._
 (    '      ,       .-`  | `,    )     Running in standalone mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 6379
 |    `-._   `._    /     _.-'    |     PID: 27569
`-._    `-._  `-./  _.-'    _.-'
 |`-._`-._    `-.__.-'    _.-'_.-'|
 |    `-._`-._        _.-'_.-'    |           http://redis.io
`-._    `-._`-.__.-'_.-'    _.-'
 |`-._`-._    `-.__.-'    _.-'_.-'|
 |    `-._`-._        _.-'_.-'    |
`-._    `-._`-.__.-'_.-'    _.-'
`-._    `-.__.-'    _.-'
`-._        _.-'
`-.__.-'
27569:M 16 Feb 202021:18:20.414 # WARNING: The TCP backlog setting of 511
cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value
of 128.

27569:M 16 Feb 202021:18:20.414 # Server initialized
27569:M 16 Feb 202021:18:20.414 # WARNING overcommit_memory is set to 0!
Background save may fail under low memory condition. To fix this issue add
'vm.overcommit_memory = 1' to /etc/sysctl.conf and then reboot or run the command
'sysctl vm.overcommit_memory=1' for this to take effect.
27569:M 16 Feb 202021:18:20.414 # WARNING you have Transparent Huge Pages (THP)
support enabled in your kernel. This will create latency and memory usage issues
with Redis. To fix this issue run the command 'echo never >
/sys/kernel/mm/transparent_hugepage/enabled' as root, and add it to your
/etc/rc.local in order to retain the setting after a reboot. Redis must be
restarted after THP is disabled.
27569:M 16 Feb 202021:18:20.414 * Ready to accept connections

[root@centos8 ~]#ss -ntl
State      Recv-Q Send-Q          Local Address:Port            Peer Address:Port
        LISTEN     0100127.0.0.1:25
  *:*
LISTEN     0128127.0.0.1:6379                       *:*
LISTEN     0128                         *:22                         *:*
LISTEN     0100                     [::1]:25                      [::]:*
LISTEN     0128                      [::]:22                      [::]:*

范例: 开启 Redis 多实例

[root@centos8 ~]#redis-server  --port 6380
[root@centos8 ~]#ss -ntl
State  Recv-Q Send-Q  Local Address:Port    Peer Address:Port
LISTEN 0511                 *:6379               *:*
LISTEN 0511                 *:6380               *:*
LISTEN 0128                 *:22                 *:*
LISTEN 0100127.0.0.1:25                 *:*
LISTEN 0511              [::]:6380            [::]:*
LISTEN 0128              [::]:22              [::]:*
LISTEN 0100             [::1]:25              [::]:*

[root@centos8 ~]#ps -ef|grep redis
redis      44071010:56 ?        00:00:01 /apps/redis/bin/redis-server
0.0.0.0:6379
root       4451963011:05 pts/0    00:00:00 redis-server *:6380
root       44844455011:09 pts/1    00:00:00 grep--color=auto redis
[root@centos8 ~]#redis-cli  -p 6380
127.0.0.1:6380>

1.2.2.3 消除启动时的三个Warning提示信息(可选)

前面直接启动Redis时有三个Waring信息,可以用下面方法消除告警,但非强制消除

1.2.2.3.1 Tcp backlog

WARNING: The TCP backlog setting of 511 cannot be enforced because
/proc/sys/net/core/somaxconn is set to the lower value of 128.

Tcp backlog 是指TCP的第三次握手服务器端收到客户端 ack确认号之后到服务器用Accept函数处理请求前的队列长度，即全连接队列

#vim /etc/sysctl.conf
net.core.somaxconn =1024
#sysctl -p

1.2.2.3.2 overcommit_memory

WARNING overcommit_memory is set to 0! Background save may fail under low memory
condition. To fix this issue add 'vm.overcommit_memory = 1' to /etc/sysctl.conf
and then reboot or run the command 'sysctl vm.overcommit_memory=1' for this to
take effect.

内核参数说明:

内核参数overcommit_memory 实现内存分配策略,可选值有三个：0、1、2

• 0 表示内核将检查是否有足够的可用内存供应用进程使用；如果有足够的可用内存，内存申请允许；否则内存申请失败，并把错误返回给应用进程

1 表示内核允许分配所有的物理内存，而不管当前的内存状态如何

2 表示内核允许分配超过所有物理内存和交换空间总和的内存

范例:

#vim /etc/sysctl.conf
vm.overcommit_memory =1
#sysctl -p

1.2.2.3.3 transparent hugepage

WARNING you have Transparent Huge Pages (THP) support enabled in your kernel.
This will create latency and memory usage issues with Redis. To fix this issue
run the command 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' as
root, and add it to your /etc/rc.local in order to retain the setting after a
reboot. Redis must be restarted after THP is disabled.

警告：您在内核中启用了透明大页面（THP,不同于一般4k内存页,而为2M）支持。这将在Redis中造成延迟
和内存使用问题。要解决此问题，请以root 用户身份运行命令“echo never>
/sys/kernel/mm/transparent_hugepage/enabled”，并将其添加到您的/etc/rc.local中，以便在
重启后保留设置。禁用THP后，必须重新启动Redis。

范例:

#查看默认值

[root@ubuntu2004 ~]#cat /sys/kernel/mm/transparent_hugepage/enabled
always [madvise] never

[root@rocky8 ~]#cat /sys/kernel/mm/transparent_hugepage/enabled
[always] madvise never

[root@centos7 ~]#cat /sys/kernel/mm/transparent_hugepage/enabled
[always] madvise never

#ubuntu开机配置
[root@ubuntu2004 ~]#cat /etc/rc.local
#!/bin/bash
echo never > /sys/kernel/mm/transparent_hugepage/enabled
[root@ubuntu2004 ~]#chmod +x /etc/rc.local

#CentOS开机配置
[root@centos8 ~]#echo 'echo never > /sys/kernel/mm/transparent_hugepage/enabled'
>> /etc/rc.d/rc.local
[root@centos8 ~]#cat /etc/rc.d/rc.local
#!/bin/bash
# THIS FILE IS ADDED FOR COMPATIBILITY PURPOSES
#
# It is highly advisable to create own systemd services or udev rules
# to run scripts during boot instead of using this file.
#
# In contrast to previous versions due to parallel execution during boot
# this script will NOT be run after all other services.
#
# Please note that you must run 'chmod +x /etc/rc.d/rc.local' to ensure
# that this script will be executed during boot.
touch /var/lock/subsys/local
echo never > /sys/kernel/mm/transparent_hugepage/enabled

[root@centos8 ~]#chmod +x /etc/rc.d/rc.local

1.2.2.3.4 验证是否消除 Warning

重新启动redis 服务不再有前面的三个Waring信息

[root@centos8 ~]#redis-server  /apps/redis/etc/redis.conf
27646:C 16 Feb 202021:26:52.690 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
27646:C 16 Feb 202021:26:52.690 # Redis version=5.0.7, bits=64,
commit=00000000, modified=0, pid=27646, just started
27646:C 16 Feb 202021:26:52.690 # Configuration loaded
27646:M 16 Feb 202021:26:52.690 * Increased maximum number of open files to
10032 (it was originally set to 1024).

                _._
           _.-``__ ''-._
      _.-```.  `_.  ''-._           Redis 5.0.7 (00000000/0) 64 bit
  .-`` .-```.  ```\/    _.,_ ''-._
 (    '      ,       .-`  | `,    )     Running in standalone mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 6379
 |    `-._   `._    /     _.-'    |     PID: 27646
`-._    `-._  `-./  _.-'    _.-'
 |`-._`-._    `-.__.-'    _.-'_.-'|
 |    `-._`-._        _.-'_.-'    |           http://redis.io
`-._    `-._`-.__.-'_.-'    _.-'
 |`-._`-._    `-.__.-'    _.-'_.-'|

 |    `-._`-._        _.-'_.-'    |
`-._    `-._`-.__.-'_.-'    _.-'
`-._    `-.__.-'    _.-'
`-._        _.-'
`-.__.-'
27646:M 16 Feb 202021:26:52.691 # Server initialized
27646:M 16 Feb 202021:26:52.692 * DB loaded from disk: 0.000 seconds
27646:M 16 Feb 202021:26:52.692 * Ready to accept connections

1.2.2.4 创建 Redis 用户和设置数据目录权限

[root@centos8 ~]#useradd -r -s /sbin/nologin redis

#设置目录权限

[root@centos8 ~]#chown -R redis.redis /apps/redis/

1.2.2.5 创建 Redis 服务 Service 文件

#可以复制CentOS8利用yum安装Redis生成的redis.service文件，进行修改
[root@centos8 ~]#scp 10.0.0.8:/lib/systemd/system/redis.service
/lib/systemd/system/
[root@centos8 ~]#cp redis-stable/utils/systemd-redis_server.service
/lib/systemd/system/redis.service

[root@centos8 ~]#vim  /lib/systemd/system/redis.service
[root@centos8 ~]#cat  /lib/systemd/system/redis.service
[Unit]
Description=Redis persistent key-value database
After=network.target

[Service]
ExecStart=/apps/redis/bin/redis-server /apps/redis/etc/redis.conf --supervised
systemd
ExecStop=/bin/kill -s QUIT $MAINPID
Type=notify #如果支持systemd可以启用此行
User=redis
Group=redis
RuntimeDirectory=redis
RuntimeDirectoryMode=0755
LimitNOFILE=1000000#指定此值才支持更大的maxclients值

[Install]
WantedBy=multi-user.target

1.2.2.6 Redis 通过Service方式启动

[root@centos8 ~]#systemctl daemon-reload
[root@centos8 ~]#systemctl start redis
[root@centos8 ~]#systemctl status redis

• redis.service - Redis persistent key-value database

   Loaded: loaded (/usr/lib/systemd/system/redis.service; enabled; vendor preset:
disabled)

   Active: active (running) since Sun 2020-02-1623:08:08 CST; 2s ago

  Process: 1667ExecStop=/bin/kill -s QUIT $MAINPID(code=exited,
status=0/SUCCESS)
 Main PID: 1669 (redis-server)
   CGroup: /system.slice/redis.service
           └─1669 /apps/redis/bin/redis-server 127.0.0.1:6379
Feb 1623:08:08 centos8.wangxiaochun.com redis-server[1669]: |`-._`-._
`-.__.-'    _.-'_.-'|
Feb 1623:08:08 centos8.wangxiaochun.com redis-server[1669]: |    `-._`-._
_.-'_.-'    |
Feb 1623:08:08 centos8.wangxiaochun.com redis-server[1669]: `-._    `-._`-.__.-
'_.-'    _.-'
Feb 1623:08:08 centos8.wangxiaochun.com redis-server[1669]: `-._    `-.__.-'
_.-'
Feb 1623:08:08 centos8.wangxiaochun.com redis-server[1669]: `-._        _.-'
Feb 1623:08:08 centos8.wangxiaochun.com redis-server[1669]: `-.__.-'
Feb 1623:08:08 centos8.wangxiaochun.com redis-server[1669]: 1669:M 16 Feb 2020
23:08:08.931 # Server ini...ed
Feb 1623:08:08 centos8.wangxiaochun.com redis-server[1669]: 1669:M 16 Feb 2020
23:08:08.931 * DB loaded ...ds
Feb 1623:08:08 centos8.wangxiaochun.com redis-server[1669]: 1669:M 16 Feb 2020
23:08:08.931 * Ready to a...ns
Feb 1623:08:08 centos7.wangxiaochun.com systemd[1]: Started Redis persistent
key-value database.
Hint: Some lines were ellipsized, use -l to show in full.
[root@centos8 ~]#ss -ntl
State      Recv-Q Send-Q      Local Address:Port               Peer Address:Port
LISTEN     0100127.0.0.1:25                            *:*
LISTEN     0511127.0.0.1:6379                          *:*
LISTEN     0128                     *:22                            *:*
LISTEN     0100                 [::1]:25                         [::]:*
LISTEN     0128                  [::]:22                         [::]:*

1.2.2.7 验证客户端连接 Redis

[root@centos8 ~]#/apps/redis/bin/redis-cli -h IP/HOSTNAME -p PORT -a PASSWORD

范例:

[root@centos8 ~]#redis-cli
127.0.0.1:6379> ping
PONG
127.0.0.1:6379> info
# Server
redis_version:5.0.7
redis_git_sha1:00000000
redis_git_dirty:0
redis_build_id:673d8c0ee1a8872
redis_mode:standalone
os:Linux 3.10.0-1062.el7.x86_64 x86_64
arch_bits:64
multiplexing_api:epoll
atomicvar_api:atomic-builtin
gcc_version:4.8.5
process_id:1669
run_id:5e0420e92e35ad1d740e9431bc655bfd0044a5d1
tcp_port:6379
uptime_in_seconds:140
uptime_in_days:0
hz:10
configured_hz:10
lru_clock:4807524
executable:/apps/redis/bin/redis-server
config_file:/apps/redis/etc/redis.conf

# Clients
connected_clients:1
client_recent_max_input_buffer:2
client_recent_max_output_buffer:0
blocked_clients:0

# Memory
used_memory:575792
used_memory_human:562.30K
used_memory_rss:3506176
used_memory_rss_human:3.34M
used_memory_peak:575792
used_memory_peak_human:562.30K
used_memory_peak_perc:100.18%
used_memory_overhead:562590
used_memory_startup:512896
used_memory_dataset:13202
used_memory_dataset_perc:20.99%
allocator_allocated:1201392
allocator_active:1531904
allocator_resident:8310784
total_system_memory:1019645952
total_system_memory_human:972.41M
used_memory_lua:37888
used_memory_lua_human:37.00K
used_memory_scripts:0
used_memory_scripts_human:0B
number_of_cached_scripts:0
maxmemory:0
maxmemory_human:0B
maxmemory_policy:noeviction
allocator_frag_ratio:1.28

allocator_frag_bytes:330512
allocator_rss_ratio:5.43
allocator_rss_bytes:6778880
rss_overhead_ratio:0.42
rss_overhead_bytes:-4804608
mem_fragmentation_ratio:6.57
mem_fragmentation_bytes:2972384
mem_not_counted_for_evict:0
mem_replication_backlog:0
mem_clients_slaves:0
mem_clients_normal:49694
mem_aof_buffer:0
mem_allocator:jemalloc-5.1.0
active_defrag_running:0
lazyfree_pending_objects:0

# Persistence

loading:0
rdb_changes_since_last_save:0
rdb_bgsave_in_progress:0
rdb_last_save_time:1581865688
rdb_last_bgsave_status:ok
rdb_last_bgsave_time_sec:-1
rdb_current_bgsave_time_sec:-1
rdb_last_cow_size:0
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_last_write_status:ok
aof_last_cow_size:0

# Stats

total_connections_received:1
total_commands_processed:2
instantaneous_ops_per_sec:0
total_net_input_bytes:45
total_net_output_bytes:11475
instantaneous_input_kbps:0.00
instantaneous_output_kbps:0.00
rejected_connections:0
sync_full:0
sync_partial_ok:0
sync_partial_err:0
expired_keys:0
expired_stale_perc:0.00
expired_time_cap_reached_count:0
evicted_keys:0
keyspace_hits:0
keyspace_misses:0
pubsub_channels:0
pubsub_patterns:0
latest_fork_usec:0
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
# Replication
role:master
connected_slaves:0
master_replid:f7228f0b6203183004fae8db00568f9f73422dc4
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:0.132821
used_cpu_user:0.124317
used_cpu_sys_children:0.000000
used_cpu_user_children:0.000000
# Cluster
cluster_enabled:0
# Keyspace
127.0.0.1:6379> exit
[root@centos7 ~]#

1.2.2.8 实战案例：一键编译安装Redis脚本

[root@ubuntu2004 ~]#cat install_redis.sh
#!/bin/bash
#
#********************************************************************
#Author:          wangxiaochun
#QQ:              29308620
#Date:            2020-07-22
#FileName：       install_redis.sh
#URL:             http://www.wangxiaochun.com
#Description:     The test script
#Copyright (C):   2020 All rights reserved
#********************************************************************
REDIS_VERSION=redis-6.2.5
PASSWORD=123456
INSTALL_DIR=/apps/redis
CPUS=`lscpu |awk '/^CPU\(s\)/{print $2}'`

. /etc/os-release

color () {
RES_COL=60
MOVE_TO_COL="echo -en \\033[${RES_COL}G"
SETCOLOR_SUCCESS="echo -en \\033[1;32m"
SETCOLOR_FAILURE="echo -en \\033[1;31m"
SETCOLOR_WARNING="echo -en \\033[1;33m"
SETCOLOR_NORMAL="echo -en \E[0m"

echo-n"$1" && $MOVE_TO_COL
echo-n"["
if [ $2="success"-o$2="0" ] ;then
${SETCOLOR_SUCCESS}
echo-n$"  OK  "
elif [ $2="failure"-o$2="1"  ] ;then
${SETCOLOR_FAILURE}
echo-n$"FAILED"
else
${SETCOLOR_WARNING}
echo-n$"WARNING"
fi
${SETCOLOR_NORMAL}
echo-n"]"
echo
}
prepare(){
if [ $ID="centos" ];then
        yum  -y install gccmake jemalloc-devel systemd-devel
else
        apt update
        apt -y install  gccmake libjemalloc-dev libsystemd-dev
fi
if [ $?-eq0 ];then
        color "安装软件包成功"0
else
        color "安装软件包失败，请检查网络配置"1
exit
fi
}
install() {
if [ ! -f${REDIS_VERSION}.tar.gz ];then
wget http://download.redis.io/releases/${REDIS_VERSION}.tar.gz || {
color "Redis 源码下载失败"1 ; exit; }
fi
    tar xf ${REDIS_VERSION}.tar.gz
cd${REDIS_VERSION}
make-j$CUPSUSE_SYSTEMD=yesPREFIX=${INSTALL_DIR} install && color "Redis
编译安装完成"0 || { color "Redis 编译安装失败"1 ;exit ; }
ln-s${INSTALL_DIR}/bin/redis-*  /usr/bin/
mkdir-p${INSTALL_DIR}/{etc,log,data,run}
cp redis.conf  ${INSTALL_DIR}/etc/

sed-i-e's/bind 127.0.0.1/bind 0.0.0.0/'-e"/# requirepass/a requirepass
$PASSWORD"-e"/^dir .*/c dir ${INSTALL_DIR}/data/"-e"/logfile .*/c logfile
${INSTALL_DIR}/log/redis-6379.log"-e"/^pidfile .*/c  pidfile
${INSTALL_DIR}/run/redis_6379.pid"${INSTALL_DIR}/etc/redis.conf

if id redis &> /dev/null ;then
         color "Redis 用户已存在"1
else
         useradd -r-s /sbin/nologin redis

         color "Redis 用户创建成功"0
fi
chown-R redis.redis ${INSTALL_DIR}
cat >> /etc/sysctl.conf <<EOF
net.core.somaxconn =1024
vm.overcommit_memory =1
EOF
    sysctl -p
if [ $ID="centos" ];then
echo'echo never > /sys/kernel/mm/transparent_hugepage/enabled' >>
/etc/rc.d/rc.local
chmod+x /etc/rc.d/rc.local
        /etc/rc.d/rc.local
else
echo-e'#!/bin/bash\necho never >
/sys/kernel/mm/transparent_hugepage/enabled' >> /etc/rc.local
chmod+x /etc/rc.local
        /etc/rc.local
fi
cat > /lib/systemd/system/redis.service <<EOF
[Unit]
Description=Redis persistent key-value database
After=network.target
[Service]
ExecStart=${INSTALL_DIR}/bin/redis-server ${INSTALL_DIR}/etc/redis.conf --
supervised systemd
ExecStop=/bin/kill -s QUIT \$MAINPID
Type=notify
User=redis
Group=redis
RuntimeDirectory=redis
RuntimeDirectoryMode=0755
LimitNOFILE=1000000
[Install]
WantedBy=multi-user.target
EOF
     systemctl daemon-reload
     systemctl enable --now  redis &> /dev/null
if [ $?-eq0 ];then
         color "Redis 服务启动成功,Redis信息如下:"0
else
         color "Redis 启动失败"1
exit
fi
sleep2
     redis-cli -a$PASSWORD INFO Server 2> /dev/null
}
prepare
install

1.2.3 Redis 的多实例

测试环境中经常使用多实例,需要指定不同实例的相应的端口,配置文件,日志文件等相关配置

范例: 以编译安装为例实现 redis 多实例

#生成的文件列表
[root@centos8 ~]#ll  /apps/redis/
total 0
drwxr-xr-x 2 redis redis 134 Oct 1522:13 bin
drwxr-xr-x 2 redis redis  69 Oct 1523:25 data
drwxr-xr-x 2 redis redis  75 Oct 1522:42 etc
drwxr-xr-x 2 redis redis  72 Oct 1523:25 log
drwxr-xr-x 2 redis redis  72 Oct 1522:47 run
[root@centos8 ~]#tree /apps/redis/
/apps/redis/
├── bin
│   ├── redis-benchmark
│   ├── redis-check-aof
│   ├── redis-check-rdb
│   ├── redis-cli
│   ├── redis-sentinel -> redis-server
│   └── redis-server
├── data
│   ├── dump_6379.rdb
│   ├── dump_6380.rdb
│   └── dump_6381.rdb
├── etc
│   ├── redis_6379.conf
│   ├── redis_6380.conf
│   └── redis_6381.conf
├── log
│   ├── redis_6379.log
│   ├── redis_6380.log
│   └── redis_6381.log
└── run
    ├── redis_6379.pid
    ├── redis_6380.pid
    └── redis_6381.pid
5 directories, 18 files
[root@centos8 ~]#sed  's/6379/6380/' /apps/redis/etc/redis6379.conf  >
/apps/redis/etc/redis6380.conf
[root@centos8 ~]#sed  's/6379/6381/' /apps/redis/etc/redis6379.conf  >
/apps/redis/etc/redis6381.conf
[root@centos8 ~]#grep '^[^#]' /apps/redis/etc/redis_6379.conf
bind 0.0.0.0
protected-mode yes
port 6379
tcp-backlog 511
timeout 0
tcp-keepalive 300
daemonize yes
supervised no

pidfile /apps/redis/run/redis_6379.pid
loglevel notice
logfile "/apps/redis/log/redis_6379.log"
databases 16
always-show-logo yes
save 9001
save 30010
save 6010000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump_6379.rdb
dir /apps/redis/data/
replica-serve-stale-data yes
replica-read-only yes
repl-diskless-sync no
repl-diskless-sync-delay 5
repl-disable-tcp-nodelay no
replica-priority 100
lazyfree-lazy-eviction no
lazyfree-lazy-expire no
lazyfree-lazy-server-del no
replica-lazy-flush no
appendonly no
appendfilename "appendonly_6379.aof"
appendfsync everysec
no-appendfsync-on-rewrite no
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
aof-load-truncated yes
aof-use-rdb-preamble yes
lua-time-limit 5000
slowlog-log-slower-than 10000
slowlog-max-len 128
latency-monitor-threshold 0
notify-keyspace-events ""
hash-max-ziplist-entries 512
hash-max-ziplist-value 64
list-max-ziplist-size -2
list-compress-depth 0
set-max-intset-entries 512
zset-max-ziplist-entries 128
zset-max-ziplist-value 64
hll-sparse-max-bytes 3000
stream-node-max-bytes 4096
stream-node-max-entries 100
activerehashing yes
client-output-buffer-limit normal 000
client-output-buffer-limit replica 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60
hz 10
dynamic-hz yes
aof-rewrite-incremental-fsync yes
rdb-save-incremental-fsync yes

[root@centos8 ~]#grep 6380 /apps/redis/etc/redis_6380.conf
# Accept connections on the specified port, default is 6380 (IANA #815344).

port 6380
pidfile /apps/redis/run/redis_6380.pid
logfile "/apps/redis/log/redis_6380.log"
dbfilename dump_6380.rdb
appendfilename "appendonly_6380.aof"
# cluster-config-file nodes-6380.conf
# cluster-announce-port 6380
# cluster-announce-bus-port 6380

[root@centos7 ~]#grep 6381 /apps/redis/etc/redis_6381.conf
# Accept connections on the specified port, default is 6381 (IANA #815344).
port 6381
pidfile /apps/redis/run/redis_6381.pid
logfile "/apps/redis/log/redis_6381.log"
dbfilename dump_6381.rdb
appendfilename "appendonly_6381.aof"
# cluster-config-file nodes-6381.conf
# cluster-announce-port 6381
[root@centos8 ~]#cat /lib/systemd/system/redis6379.service
[Unit]
Description=Redis persistent key-value database
After=network.target

[Service]
ExecStart=/apps/redis/bin/redis-server /apps/redis/etc/redis_6379.conf --
supervised systemd
#ExecStop=/usr/libexec/redis-shutdown
ExecStop=/bin/kill -s QUIT $MAINPID
Type=notify
User=redis
Group=redis
RuntimeDirectory=redis
RuntimeDirectoryMode=0755

[Install]
WantedBy=multi-user.target
[root@centos8 ~]#cat /lib/systemd/system/redis6380.service
[Unit]
Description=Redis persistent key-value database
After=network.target
[Service]
ExecStart=/apps/redis/bin/redis-server /apps/redis/etc/redis_6380.conf --
supervised systemd
#ExecStop=/usr/libexec/redis-shutdown
ExecStop=/bin/kill -s QUIT $MAINPID
Type=notify
User=redis
Group=redis
RuntimeDirectory=redis
RuntimeDirectoryMode=0755

[Install]
WantedBy=multi-user.target

[root@centos8 ~]#cat /lib/systemd/system/redis6381.service
[Unit]
Description=Redis persistent key-value database
After=network.target

[Service]
ExecStart=/apps/redis/bin/redis-server /apps/redis/etc/redis_6381.conf --
supervised systemd
#ExecStop=/usr/libexec/redis-shutdown
ExecStop=/bin/kill -s QUIT $MAINPID
Type=notify
User=redis
Group=redis
RuntimeDirectory=redis
RuntimeDirectoryMode=0755

[Install]
WantedBy=multi-user.target

[root@centos8 ~]#systemctl daemon-reload
[root@centos8 ~]#systemctl enable --now redis6379 redis6380 redis6381
[root@centos8 ~]#ss -ntl
State      Recv-Q Send-Q      Local Address:Port    Peer Address:Port
LISTEN     0128                     *:22                 *:*
LISTEN     0100127.0.0.1:25                 *:*
LISTEN     0511                     *:6379               *:*
LISTEN     0511                     *:6380               *:*
LISTEN     0511                     *:6381               *:*
LISTEN     0128                  [::]:22              [::]:*
LISTEN     0100                 [::1]:25              [::]:*

1.2.4 Redis 相关工具和客户端连接

1.2.4.1 安装的相关程序介绍

[root@centos8 ~]#ll /apps/redis/bin/
total 32772
-rwxr-xr-x1 root root 4366792 Feb 1621:12 redis-benchmark #性能测试程序
-rwxr-xr-x1 root root 8125184 Feb 1621:12 redis-check-aof #AOF文件检查程序
-rwxr-xr-x1 root root 8125184 Feb 1621:12 redis-check-rdb #RDB文件检查程序
-rwxr-xr-x1 root root 4807856 Feb 1621:12 redis-cli       #客户端程序
lrwxrwxrwx 1 root root      12 Feb 1621:12 redis-sentinel -> redis-server #哨兵程
序，软连
接到服务器端主程序
-rwxr-xr-x1 root root 8125184 Feb 1621:12 redis-server #服务端主程序

1.2.4.2 客户端程序 redis-cli

#默认为本机无密码连接
redis-cli
#远程客户端连接,注意:Redis没有用户的概念
redis-cli -h <Redis服务器IP> -p <PORT> -a <PASSWORD>

1.2.4.3 程序连接 Redis

Redis 支持多种开发语言访问

https://redis.io/clients

2.2.4.2.1 Shell 脚本访问 Redis

[root@centos8 ~]#cat redis_test.sh
#!/bin/bash
NUM=100
PASS=123456
for i in`seq $NUM`;do
    redis-cli -h127.0.0.1 -a"$PASS"--no-auth-warningset key${i} value${i}
echo"key${i} value${i}写入完成"
done
echo"$NUM个key写入完成"

2.2.4.2.2 Python 程序连接 Redis

python 提供了多种开发库,都可以支持连接访问 Redis

https://redis.io/clients

下面选择使用redis-py 库连接 Redis

github redis-py库 :

https://github.com/andymccurdy/redis-py

范例:

[root@centos8 ~]#yum info  python3-redis
Last metadata expiration check: 1 day, 10:19:31 ago on Thu 15 Oct 202011:03:33
PM CST.
Installed Packages
Name         : python3-redis
Version      : 3.3.8

Release      : 1.el8
Architecture : noarch
Size         : 523 k
Source       : python-redis-3.3.8-1.el8.src.rpm
Repository   : @System
From repo    : epel
Summary      : Python 3 interface to the Redis key-value store
URL          : https://github.com/andymccurdy/redis-py
License      : MIT
Description  : This is a Python 3 interface to the Redis key-value store.
[root@ubuntu2004 ~]#apt -y install python3-pip python3-redis
[root@centos8 ~]#yum -y install python3 python3-redis
#注意文件名不要为redis,会和redis模块名称冲突
[root@centos8 ~]#cat redis_test.py
!/usr/bin/python3
import redis
pool =
redis.ConnectionPool(host="127.0.0.1",port=6379,password="123456",decode_respons
es=True)
c = redis.Redis(connection_pool=pool)
for i in range(100):
    c.set("k%d" % i,"v%d" % i)
data=c.get("k%d" % i)
    print(data)
[root@centos8 ~]# python3 redis_test.py
......
'v94'
'v95'
'v96'
'v97'
'v98'
'v99'
[root@centos8 ~]#redis-cli
127.0.0.1:6379> get k10
"v10"
127.0.0.1:6379>

2.2.4.4 图形工具

有一些第三方开发的图形工具也可以连接redis, 比如: RedisDesktopManager

2 Redis 配置管理

2.1 Redis 配置文件说明

bind 0.0.0.0 #指定监听地址，支持用空格隔开的多个监听IP

protected-mode yes#redis3.2之后加入的新特性，在没有设置bind IP和密码的时候,redis只允许访
问127.0.0.1:6379，可以远程连接，但当访问将提示警告信息并拒绝远程访问

port 6379#监听端口,默认6379/tcp

tcp-backlog 511#三次握手的时候server端收到client ack确认号之后的队列值，即全连接队列长度

timeout 0#客户端和Redis服务端的连接超时时间，默认是0，表示永不超时

tcp-keepalive 300#tcp 会话保持时间300s

daemonize no #默认no,即直接运行redis-server程序时,不作为守护进程运行，而是以前台方式运行，
如果想在后台运行需改成yes,当redis作为守护进程运行的时候，它会写一个 pid 到
/var/run/redis.pid 文件

supervised no #和OS相关参数，可设置通过upstart和systemd管理Redis守护进程，centos7后都使
用systemd

pidfile /var/run/redis_6379.pid #pid文件路径,可以修改
为/apps/redis/run/redis_6379.pid

loglevel notice #日志级别

logfile "/path/redis.log"#日志路径,示例:logfile "/apps/redis/log/redis_6379.log"

databases 16#设置数据库数量，默认：0-15，共16个库

always-show-logo yes#在启动redis 时是否显示或在日志中记录记录redis的logo

save 9001#在900秒内有1个key内容发生更改,就执行快照机制
save 30010#在300秒内有10个key内容发生更改,就执行快照机制
save 6010000#60秒内如果有10000个key以上的变化，就自动快照备份

stop-writes-on-bgsave-error yes#默认为yes时,可能会因空间满等原因快照无法保存出错时，会禁
止redis写入操作，生产建议为no

#此项只针对配置文件中的自动save有效

rdbcompression yes#持久化到RDB文件时，是否压缩，"yes"为压缩，"no"则反之

rdbchecksum yes#是否对备份文件开启RC64校验，默认是开启

dbfilename dump.rdb #快照文件名

dir ./ #快照文件保存路径，示例：dir "/apps/redis/data"

#主从复制相关

# replicaof <masterip> <masterport>  #指定复制的master主机地址和端口，5.0版之前的指令为
slaveof

# masterauth <master-password> #指定复制的master主机的密码

replica-serve-stale-data yes#当从库同主库失去连接或者复制正在进行，从机库有两种运行方式：
1、设置为yes(默认设置)，从库会继续响应客户端的读请求，此为建议值

2、设置为no，除去特定命令外的任何请求都会返回一个错误"SYNC with master in progress"。

replica-read-only yes#是否设置从库只读，建议值为yes,否则主库同步从库时可能会覆盖数据，造成
数据丢失

repl-diskless-sync no #是否使用socket方式复制数据(无盘同步)，新slave第一次连接master时需
要做数据的全量同步，redis server就要从内存dump出新的RDB文件，然后从master传到slave，有两种
方式把RDB文件传输给客户端：

1、基于硬盘（disk-backed）：为no时，master创建一个新进程dump生成RDB磁盘文件，RDB完成之后由
父进程（即主进程）将RDB文件发送给slaves，此为默认值

2、基于socket（diskless）：master创建一个新进程直接dump RDB至slave的网络socket，不经过主
进程和硬盘

#推荐使用基于硬盘（为no），是因为RDB文件创建后，可以同时传输给更多的slave，但是基于socket(为
yes)，新slave连接到master之后得逐个同步数据。只有当磁盘I/O较慢且网络较快时，可用
diskless(yes),否则一般建议使用磁盘(no)

repl-diskless-sync-delay 5#diskless时复制的服务器等待的延迟时间，设置0为关闭，在延迟时间
内到达的客户端，会一起通过diskless方式同步数据，但是一旦复制开始，master节点不会再接收新slave
的复制请求，直到下一次同步开始才再接收新请求。即无法为延迟时间后到达的新副本提供服务，新副本将排
队等待下一次RDB传输，因此服务器会等待一段时间才能让更多副本到达。推荐值：30-60

repl-ping-replica-period 10#slave根据master指定的时间进行周期性的PING master,用于监测
master状态,默认10s

repl-timeout 60#复制连接的超时时间，需要大于repl-ping-slave-period，否则会经常报超时

repl-disable-tcp-nodelay no #是否在slave套接字发送SYNC之后禁用 TCP_NODELAY，如果选
择"yes"，Redis将合并多个报文为一个大的报文，从而使用更少数量的包向slaves发送数据，但是将使数据
传输到slave上有延迟，Linux内核的默认配置会达到40毫秒，如果 "no" ，数据传输到slave的延迟将会
减少，但要使用更多的带宽

repl-backlog-size 512mb #复制缓冲区内存大小，当slave断开连接一段时间后，该缓冲区会累积复制
副本数据，因此当slave 重新连接时，通常不需要完全重新同步，只需传递在副本中的断开连接后没有同步的
部分数据即可。只有在至少有一个slave连接之后才分配此内存空间,建议建立主从时此值要调大一些或在低峰
期配置,否则会导致同步到slave失败

repl-backlog-ttl 3600#多长时间内master没有slave连接，就清空backlog缓冲区

replica-priority 100#当master不可用，哨兵Sentinel会根据slave的优先级选举一个master，此
值最低的slave会优先当选master，而配置成0，永远不会被选举，一般多个slave都设为一样的值，让其自
动选择

#min-replicas-to-write 3  #至少有3个可连接的slave，mater才接受写操作
#min-replicas-max-lag 10  #和上面至少3个slave的ping延迟不能超过10秒，否则master也将停止
写操作

requirepass foobared #设置redis连接密码，之后需要AUTH pass,如果有特殊符号，用" "引起来,生
产建议设置
rename-command #重命名一些高危命令，示例：rename-command FLUSHALL "" 禁用命令
#示例: rename-command del wang

maxclients 10000#Redis最大连接客户端

maxmemory <bytes> #redis使用的最大内存，单位为bytes字节，0为不限制，建议设为物理内存一半，
8G内存的计算方式8(G)*1024(MB)1024(KB)*1024(Kbyte)，需要注意的是缓冲区是不计算在maxmemory
内,生产中如果不设置此项,可能会导致OOM

#maxmemory-policy noeviction 此为默认值
# MAXMEMORY POLICY：当达到最大内存时，Redis 将如何选择要删除的内容。您可以从以下行为中选择一
种：
#
# volatile-lru -> Evict 使用近似 LRU，只有设置了过期时间的键。
# allkeys-lru -> 使用近似 LRU 驱逐任何键。
# volatile-lfu -> 使用近似 LFU 驱逐，只有设置了过期时间的键。
# allkeys-lfu -> 使用近似 LFU 驱逐任何键。
# volatile-random -> 删除设置了过期时间的随机密钥。
# allkeys-random -> 删除一个随机密钥，任何密钥。
# volatile-ttl -> 删除过期时间最近的key（次TTL）
# noeviction -> 不要驱逐任何东西，只是在写操作时返回一个错误。
#
# LRU 表示最近最少使用
# LFU 表示最不常用
#
# LRU、LFU 和 volatile-ttl 都是使用近似随机算法实现的。
#
# 注意：使用上述任何一种策略，当没有合适的键用于驱逐时，Redis 将在需要更多内存的写操作时返回错
误。这些通常是创建新密钥、添加数据或修改现有密钥的命令。一些示例是：SET、INCR、HSET、LPUSH、
SUNIONSTORE、SORT（由于 STORE 参数）和 EXEC（如果事务包括任何需要内存的命令）。

#MAXMEMORY POLICY：当达到最大内存时，Redis 将如何选择要删除的内容。可以从下面行为中进行选
择：
# volatile-lru -> 在具有过期集的键中使用近似 LRU 驱逐。
# allkeys-lru -> 使用近似 LRU 驱逐任何键。
# volatile-lfu -> 在具有过期集的键中使用近似 LFU 驱逐。
# allkeys-lfu -> 使用近似 LFU 驱逐任何键。
# volatile-random -> 从具有过期设置的密钥中删除一个随机密钥。
# allkeys-random -> 删除一个随机密钥，任何密钥。
# volatile-ttl -> 删除过期时间最近的key（次TTL）
# noeviction -> 不要驱逐任何东西，只是在写操作时返回一个错误。
#
# LRU 表示最近最少使用
# LFU 表示最不常用
#
# LRU、LFU 和 volatile-ttl 均使用近似实现随机算法。
#
# 注意：使用上述任何一种策略，Redis 都会在写入时返回错误操作，当没有合适的键用于驱逐时。

appendonly no #是否开启AOF日志记录，默认redis使用的是rdb方式持久化，这种方式在许多应用中已经
足够用了，但是redis如果中途宕机，会导致可能有几分钟的数据丢失(取决于dump数据的间隔时间)，根据
save来策略进行持久化，Append Only File是另一种持久化方式，可以提供更好的持久化特性，Redis会
把每次写入的数据在接收后都写入 appendonly.aof 文件，每次启动时Redis都会先把这个文件的数据读入
内存里，先忽略RDB文件。默认不启用此功能

appendfilename "appendonly.aof"#文本文件AOF的文件名，存放在dir指令指定的目录中

appendfsync everysec #aof持久化策略的配置
#no表示由操作系统保证数据同步到磁盘,Linux的默认fsync策略是30秒，最多会丢失30s的数据
#always表示每次写入都执行fsync，以保证数据同步到磁盘,安全性高,性能较差
#everysec表示每秒执行一次fsync，可能会导致丢失这1s数据,此为默认值,也生产建议值

#同时在执行bgrewriteaof操作和主进程写aof文件的操作，两者都会操作磁盘，而bgrewriteaof往往会
涉及大量磁盘操作，这样就会造成主进程在写aof文件的时候出现阻塞的情形,以下参数实现控制
no-appendfsync-on-rewrite no #在aof rewrite期间,是否对aof新记录的append暂缓使用文件同步
策略,主要考虑磁盘IO开支和请求阻塞时间。

#默认为no,表示"不暂缓",新的aof记录仍然会被立即同步到磁盘，是最安全的方式，不会丢失数据，但是要
忍受阻塞的问题

#为yes,相当于将appendfsync设置为no，这说明并没有执行磁盘操作，只是写入了缓冲区，因此这样并不
会造成阻塞（因为没有竞争磁盘），但是如果这个时候redis挂掉，就会丢失数据。丢失多少数据呢？Linux
的默认fsync策略是30秒，最多会丢失30s的数据,但由于yes性能较好而且会避免出现阻塞因此比较推荐

#rewrite 即对aof文件进行整理,将空闲空间回收,从而可以减少恢复数据时间

auto-aof-rewrite-percentage 100#当Aof log增长超过指定百分比例时，重写AOF文件，设置为0表
示不自动重写Aof日志，重写是为了使aof体积保持最小，但是还可以确保保存最完整的数据

auto-aof-rewrite-min-size 64mb #触发aof rewrite的最小文件大小

aof-load-truncated yes#是否加载由于某些原因导致的末尾异常的AOF文件(主进程被kill/断电等)，
建议yes

aof-use-rdb-preamble no #redis4.0新增RDB-AOF混合持久化格式，在开启了这个功能之后，AOF重
写产生的文件将同时包含RDB格式的内容和AOF格式的内容，其中RDB格式的内容用于记录已有的数据，而AOF
格式的内容则用于记录最近发生了变化的数据，这样Redis就可以同时兼有RDB持久化和AOF持久化的优点（既
能够快速地生成重写文件，也能够在出现问题时，快速地载入数据）,默认为no,即不启用此功能

lua-time-limit 5000#lua脚本的最大执行时间，单位为毫秒

cluster-enabled yes#是否开启集群模式，默认不开启,即单机模式

cluster-config-file nodes-6379.conf #由node节点自动生成的集群配置文件名称

cluster-node-timeout 15000#集群中node节点连接超时时间，单位ms,超过此时间，会踢出集群

cluster-replica-validity-factor 10#单位为次,在执行故障转移的时候可能有些节点和master断
开一段时间导致数据比较旧，这些节点就不适用于选举为master，超过这个时间的就不会被进行故障转移,不
能当选master，计算公式：(node-timeout * replica-validity-factor) + repl-ping-
replica-period

cluster-migration-barrier 1#集群迁移屏障，一个主节点至少拥有1个正常工作的从节点，即如果主
节点的slave节点故障后会将多余的从节点分配到当前主节点成为其新的从节点。

cluster-require-full-coverage yes#集群请求槽位全部覆盖，如果一个主库宕机且没有备库就会出
现集群槽位不全，那么yes时redis集群槽位验证不全,就不再对外提供服务(对key赋值时,会出现
CLUSTERDOWN The cluster is down的提示,cluster_state:fail,但ping 仍PONG)，而no则可以
继续使用,但是会出现查询数据查不到的情况(因为有数据丢失)。生产建议为no

cluster-replica-no-failover no #如果为yes,此选项阻止在主服务器发生故障时尝试对其主服务器进
行故障转移。但是，主服务器仍然可以执行手动强制故障转移，一般为no

#Slow log 是 Redis 用来记录超过指定执行时间的日志系统，执行时间不包括与客户端交谈，发送回复等
I/O操作，而是实际执行命令所需的时间（在该阶段线程被阻塞并且不能同时为其它请求提供服务）,由于
slow log 保存在内存里面，读写速度非常快，因此可放心地使用，不必担心因为开启 slow log 而影响
Redis 的速度

slowlog-log-slower-than 10000#以微秒为单位的慢日志记录，为负数会禁用慢日志，为0会记录每个
命令操作。默认值为10ms,一般一条命令执行都在微秒级,生产建议设为1ms-10ms之间

slowlog-max-len 128#最多记录多少条慢日志的保存队列长度，达到此长度后，记录新命令会将最旧的命
令从命令队列中删除，以此滚动删除,即,先进先出,队列固定长度,默认128,值偏小,生产建议设为1000以上

2.2 config 命令实现动态修改配置

config 命令用于查看当前redis配置、以及不重启redis服务实现动态更改redis配置等

注意：不是所有配置都可以动态修改,且此方式无法持久保存

CONFIGSETparameter value
时间复杂度：O(1)
CONFIG SET 命令可以动态地调整 Redis 服务器的配置(configuration)而无须重启。

可以使用它修改配置参数，或者改变 Redis 的持久化(Persistence)方式。
CONFIG SET 可以修改的配置参数可以使用命令 CONFIG GET * 来列出，所有被 CONFIG SET 修改的配
置参数都会立即生效。

CONFIG GET parameter
时间复杂度： O(N)，其中 N 为命令返回的配置选项数量。
CONFIG GET 命令用于取得运行中的 Redis 服务器的配置参数(configuration parameters)，在
Redis 2.4 版本中，有部分参数没有办法用 CONFIG GET 访问，但是在最新的 Redis 2.6 版本中，所
有配置参数都已经可以用 CONFIG GET 访问了。

CONFIG GET 接受单个参数 parameter 作为搜索关键字，查找所有匹配的配置参数，其中参数和值以“键-
值对”(key-value pairs)的方式排列。

比如执行 CONFIG GET s* 命令，服务器就会返回所有以 s 开头的配置参数及参数的值：

2.2.1 设置客户端连接密码

#设置连接密码
127.0.0.1:6379> CONFIG SET requirepass 123456
OK
#查看连接密码
127.0.0.1:6379> CONFIG GET requirepass
1) "requirepass"
2) "123456"

2.2.2 获取当前配置

#奇数行为键，偶数行为值
127.0.0.1:6379> CONFIG GET *
1) "dbfilename"
2) "dump.rdb"
3) "requirepass"
4) ""
5) "masterauth"
6) ""
7) "cluster-announce-ip"
8) ""
9) "unixsocket"
10) ""
11) "logfile"
12) "/var/log/redis/redis.log"
13) "pidfile"
14) "/var/run/redis_6379.pid"
15) "slave-announce-ip"
16) ""
17) "replica-announce-ip"
18) ""
19) "maxmemory"
20) "0"
......
#查看bind
127.0.0.1:6379> CONFIG GET bind
1) "bind"
2) "0.0.0.0"
#Redis5.0有些设置无法修改,Redis6.2.6版本支持修改bind
127.0.0.1:6379> CONFIG SET bind 127.0.0.1
(error) ERR Unsupported CONFIG parameter: bind

2.2.3 设置 Redis 使用的最大内存量

127.0.0.1:6379> CONFIG SET maxmemory 8589934592或 1g|G
127.0.0.1:6379> CONFIG GET maxmemory
1) "maxmemory"
2) "8589934592"

2.3 慢查询

范例: SLOW LOG

[root@centos8 ~]#vim /etc/redis.conf
slowlog-log-slower-than 1#单位为us，指定超过1us即为慢的指令，默认值为10000us
slowlog-max-len 1024#指定只保存最近的1024条慢记录，默认值为128
127.0.0.1:6379> SLOWLOG LEN  #查看慢日志的记录条数
(integer) 14
127.0.0.1:6379> SLOWLOG GET [n] #查看慢日志的最近n条记录，默认为10
1) 1) (integer) 14
2) (integer) 1544690617
3) (integer) 4#第3)行表示每条指令的执行时长
4) 1) "slowlog"
127.0.0.1:6379> SLOWLOG GET 3
1) 1) (integer) 7
2) (integer) 1602901545
3) (integer) 26
4) 1) "SLOWLOG"
2) "get"
5) "127.0.0.1:38258"
6) ""
2) 1) (integer) 6
2) (integer) 1602901540
3) (integer) 22
4) 1) "SLOWLOG"
2) "get"
3) "2"
5) "127.0.0.1:38258"
6) ""
3) 1) (integer) 5
2) (integer) 1602901497
3) (integer) 22
4) 1) "SLOWLOG"
2) "GET"
5) "127.0.0.1:38258"
6) ""
127.0.0.1:6379> SLOWLOG RESET #清空慢日志
OK

2.4 Redis 持久化

Redis 是基于内存型的NoSQL, 和MySQL是不同的,使用内存进行数据保存

如果想实现数据的持久化,Redis也也可支持将内存数据保存到硬盘文件中

Redis支持两种数据持久化保存方法

RDB:Redis DataBase

AOF:AppendOnlyFile

2.4.1 RDB

2.4.1.1 RDB 工作原理

RDB(Redis DataBase)：是基于某个时间点的快照，注意RDB只保留当前最新版本的一个快照

RDB 持久化功能所生成的 RDB 文件是一个经过压缩的二进制文件，通过该文件可以还原生成该 RDB 文件时数据库的状态。因为 RDB 文件是保存在磁盘中的，所以即便 Redis 服务进程甚至服务器宕机，只要磁盘中 RDB 文件存在，就能将数据恢复

RDB bgsave 实现快照的具体过程:

首先从redis 主进程先fork生成一个新的子进程,此子进程负责将Redis内存数据保存为一个临时文件tmp<子进程pid>.rdb，当数据保存完成后,再将此临时文件改名为RDB文件,如果有前一次保存的RDB文件则会被替换，最后关闭此子进程

由于Redis只保留最后一个版本的RDB文件,如果想实现保存多个版本的数据,需要人为实现

范例： save 执行过程会使用主进程进行快照

[root@centos7 data]#redis-cli -a 123456 save&
[1] 28684
[root@centos7 data]#pstree -p |grep redis ;ll /apps/redis/data
           |-redis-server(28650)-+-{redis-server}(28651)
           |                     |-{redis-server}(28652)
           |                     |-{redis-server}(28653)
           |                     `-{redis-server}(28654)
           |           |                         `-redis-cli(28684)
           |           `-sshd(23494)---bash(23496)---redis-cli(28601)
total 251016
-rw-r--r--1 redis redis 189855682 Nov 1715:02 dump.rdb
-rw-r--r--1 redis redis  45674498 Nov 1715:02 temp-28650.rdb

2.4.1.2 RDB 相关配置

#在配置文件中的 save 选项设置多个保存条件，只有任何一个条件满足，服务器都会自动执行 BGSAVE 命
令
save 9001#900s内修改了1个key即触发保存RDB
save 30010#300s内修改了10个key即触发保存RDB
save 6010000#60s内修改了10000个key即触发保存RDB
dbfilename dump.rdb
dir ./             #编泽编译安装时默认RDB文件存放在Redis的工作目录,此配置可指定保存的数据目
录
stop-writes-on-bgsave-error yes#当快照失败是否仍允许写入,yes为出错后禁止写入,建议为no
rdbcompression yes
rdbchecksum yes

范例：RDB 相关配置

[root@ubuntu2004 ~]#grep save /apps/redis/etc/redis.conf
# save <seconds> <changes>
# Redis will save the DB if both the given number of seconds and the given
# save ""
# Unless specified otherwise, by default Redis will save the DB:
# save 3600 1
# save 300 100
# save 60 10000
#以上是默认值

[root@ubuntu2004 ~]#redis-cli config get save
1) "save"
2) "3600 1 300 100 60 10000"
#禁用系统的自动快照
[root@ubuntu2004 ~]#vim /apps/redis/etc/redis.conf
save ""
# save 3600 1
# save 300 100
# save 60 10000

2.4.1.3 实现 RDB 方法

save: 同步,不推荐使用，使用主进程完成快照，因此会阻赛其它命令执行

bgsave: 异步后台执行,不影响其它命令的执行，会开启独立的子进程，因此不会阻赛其它命令执行配置文件实现自动保存: 在配置文件中制定规则,自动执行bgsave

2.4.1.4 RDB 模式的优缺点

2.4.1.4.1 RDB 模式优点

• RDB快照只保存某个时间点的数据，恢复的时候直接加载到内存即可，不用做其他处理，这种文件适合用于做灾备处理.可以通过自定义时间点执行redis指令bgsave或者save保存快照，实现多个版本的备份

比如: 可以在最近的24小时内，每小时备份一次RDB文件，并且在每个月的每一天，也备份一个 RDB文件。这样的话，即使遇上问题，也可以随时将数据集还原到指定的不同的版本。

RDB在大数据集时恢复的速度比AOF方式要快

2.4.1.4.2 RDB 模式缺点

不能实时保存数据，可能会丢失自上一次执行RDB备份到当前的内存数据

如果需要尽量避免在服务器故障时丢失数据，那么RDB并不适合。虽然Redis允许设置不同的保存点（save point）来控制保存RDB文件的频率，但是，因为RDB文件需要保存整个数据集的状态， 所以它可能并不是一个非常快速的操作。因此一般会超过5分钟以上才保存一次RDB文件。在这种情况下，一旦发生故障停机，就可能会丢失较长时间的数据。

在数据集比较庞大时，fork()子进程可能会非常耗时，造成服务器在一定时间内停止处理客户端请求,如果数据集非常巨大，并且CPU时间非常紧张的话，那么这种停止时间甚至可能会长达整整一秒或更久。另外子进程完成生成RDB文件的时间也会花更长时间.

范例: 手动执行备份RDB

[root@rocky8 ~]#redis-cli
127.0.0.1:6379> debug populate 5000000
OK
(3.96s)
127.0.0.1:6379> dbsize
(integer) 5000000
127.0.0.1:6379> get key:0
"value:0"
127.0.0.1:6379> get key:1
"value:1"
127.0.0.1:6379> get key:2
"value:2"
127.0.0.1:6379> get key:499999
"value:499999"
127.0.0.1:6379> get key:5000000
(nil)
127.0.0.1:6379> bgsave
Background saving started
[root@rocky8 ~]#ll /var/lib/redis/ -h
total 127M
-rw-r--r--1 redis redis 127M Jun 1323:07 dump.rdb

范例: 手动备份RDB文件的脚本

#配置文件
[root@centos7 ~]#vim /apps/redis/etc/redis.conf
save ""
dbfilename dump_6379.rdb
dir "/data/redis"
appendonly no
#脚本
[root@centos8 ~]#cat redis_backup_rdb.sh
#!/bin/bash
#
#********************************************************************
#Author:            wangxiaochun
#QQ:                29308620
#Date:              2020-10-21
#FileName:          redis_rdb.sh
#URL:               http://www.wangxiaochun.com
#Description:       The test script