非关系型数据库-NoSQL（Redis）

曾经终败给现在 2022-11-10 01:09 178阅读 0赞

## 一、概念 ##

### 1. 什么是NoSQL？ ###

NoSQL(NoSQL = Not Only SQL )，意为反SQL运动，是一项全新的数据库革命性运动，2000年前就有人提出，发展至2009年趋势越发高涨。它是指运用非关系型的数据存储，相对于铺天盖地的关系型数据库运用，这一概念无疑是一种全新的思维的注入。  
随着互联网web2.0网站的兴起，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0 纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，尤其是大数据应用难题。

<table> 
 <thead> 
  <tr> 
   <th align="center">分类</th> 
   <th align="center">Examples举例</th> 
   <th align="center">典型应用场景</th> 
   <th align="center">数据模型</th> 
   <th align="center">优点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">键值（key-value）</td> 
   <td align="center">Tokyo Cabinet/Tyrant, Redis, Voldemort, Oracle BDB</td> 
   <td align="center">内容缓存，主要用于处理大量数据的高访问负载，也用于一些日志系统等等。</td> 
   <td align="center">Key 指向 Value 的键值对，通常用hash table来实现</td> 
   <td align="center">查找速度快</td> 
  </tr> 
  <tr> 
   <td align="center">列存储数据库</td> 
   <td align="center">Cassandra, HBase, Riak</td> 
   <td align="center">分布式的文件系统</td> 
   <td align="center">以列簇式存储，将同一列数据存在一起</td> 
   <td align="center">查找速度快，可扩展性强，更容易进行分布式扩展</td> 
  </tr> 
  <tr> 
   <td align="center">文档型数据库</td> 
   <td align="center">CouchDB, MongoDB</td> 
   <td align="center">Web应用（与Key-Value类似，Value是结构化的，不同的是数据库能够了解Value的内容）</td> 
   <td align="center">Key-Value对应的键值对，Value为结构化数据</td> 
   <td align="center">数据结构要求不严格，表结构可变，不需要像关系型数据库一样需要预先定义表结构</td> 
  </tr> 
  <tr> 
   <td align="center">图形(Graph)数据库</td> 
   <td align="center">Neo4J, InfoGrid, Infinite Graph</td> 
   <td align="center">社交网络，推荐系统等。专注于构建关系图谱</td> 
   <td align="center">图结构</td> 
   <td align="center">利用图结构相关算法。比如最短路径寻址，N度关系查找等</td> 
  </tr> 
 </tbody> 
</table>

### 2. NoSQL的特性？ ###

NoSQL是key-value形式存储，和传统的关系型数据库不一样,不一定遵循传统数据库的一些基本要求，比如说遵循SQL标准、ACID属性、表结构等等。

这类数据库主要有以下特点：  
1、非关系型的、分布式、开源的、水平可扩展的  
2、处理超大量数据  
3、击碎了性能瓶颈  
4、对数据高并发读写  
5、对海量数据的高效率存储和访问  
6、对数据的高扩展性和高可用性

### 3. 什么是Redis？ ###

Redis是一个开源的，先进的key-value存储。它通常被称为数据结构服务器，因为键可以包含string（字符串）、hash（哈希）、list（链表）、set（集合）和zset（sorted-set–有序集合）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作。

Redis和Memcached类似，它支持存储的value类型相对更多，与memcached一样，为了保证效率，数据都是缓存在内存中，区别是Redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDQyNjc5Mg_size_16_color_FFFFFF_t_70]

## 二、Redis 安装部署 ##

Redis的官方网站是：http://redis.io

**下载安装包：**

# wget http://download.redis.io/releases/redis-2.8.6.tar.gz

**编译安装：**

# tar –zxvf redis-2.8.6.tar.gz
    # cd redis-2.8.6
    # make
    # make PREFIX=/usr/local/redis install
    指定安装位置，如果没有指定安装位置PREFIX=/usr/local/redis，则make install会把redis安装到/usr/local/bin/目录下
    # mkdir /usr/local/redis/etc
    # cp ./redis.conf  /usr/local/redis/etc/
    复制Redis的配置文件到/usr/local/redis/etc/下，便于管理。

**修改配置文件：**

# vi /usr/local/redis/etc/redis.conf
    	daemonize no     修改为yes             #后台启动
    	dir  ./          修改为具体的绝对路径    #将redis数据库文件保存在哪个位置 例：/usr/local/redis/data

**启动服务：**

# /usr/local/redis/bin/redis-server 配置文件(/usr/local/redis)		必须指定配置文件位置，否则会提示警告

**客户端连接：**

# /usr/local/redis/bin/redis-cli
    	-h  IP：       连接指定的redis服务器
    	-p  6379：     指定redis服务器的端口
    	-a  密码：     使用密码登录
    	-n  数据库号： 指定连接哪个数据库
    	--raw：         redis支持存储中文

**停止Redis：**

# /usr/local/redis/bin/redis-cli shutdown
    或
    # pkill -9 redis

## 三、Redis 常用命令 ##

### 1) string类型及操作 ###

string是最简单的类型，一个key对应一个value，string类型是二进制安全的。redis的string可以包含任何数据。

1、set：设置key对应的值为string类型  
例如：我们添加一个name=kernel的键值对应  
redis127.0.0.1:6379>set name kernel

2、setnx：设置key对应的值为string类型，如果 key已经存在，返回0，nx是not exist的意思

3、get：获取key对应的string值，如果key不存在返回nil

4、mset & mget 同时设置和获取多个键值对

5、incrby：对key的值做加加（指定值）操作，并返回新的值

6、del：删除一个已创建的key

### 2) hash类型及操作 ###

Redis hash是一个string类型的field（字段）和value的映射表，它的添加、删除操作都是0(1)平均；hash特别适合用于存储对象，相较于将对象的每个字段存成单个string类型，将一个对象存储在hash类型中会占用更少的内存，并且可以更方便的存取整个对象。

1、hset：设置hash field 为指定值，如果key不存在，则先创建。  
例如：为num1表创建一个叫name字段（key），键值是liuchuan

redis127.0.0.1:6379> hset num1 name liu

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDQyNjc5Mg_size_16_color_FFFFFF_t_70 1]

2、hget、hmset、hmget意义同上近似

3、hdel：删除指定表中的某一个键值对

4、hgetall：列出表中的所有键值对

### 3) list类型及操作 ###

list是一个链表结构，主要功能是push、pop、获取一个范围内的所有值等等，操作中key理解为链表的名字。Redis的list类型其实就是一个每个子元素都是string类型的双向链表。我们可以通过push、pop操作从链表的头部或尾部添加删除元素。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDQyNjc5Mg_size_16_color_FFFFFF_t_70 2]

1、lpush：在key对应list的头部添加字符串元素。

redis127.0.0.1:6379> lpush zhangsan zhangsan
    redis127.0.0.1:6379> lpush zhangsan 18

2、lrange：从指定链表中获取指定范围的元素

redis127.0.0.1:6379> lrange zhangsan 0 -1
    0 -1：此范围代表全部元素，意为从头到尾

3、lpush、rpush、lpop、rpop、lrange详见图示

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDQyNjc5Mg_size_16_color_FFFFFF_t_70 3]

### 4) Set类型及操作 ###

set是集合，他是string类型的无序集合。Set是通过hash table实现的，合/并集 、交集、差集。通过这些操作我们可以实现社交网站中的好友推荐和blog的tag功能。集合不允许有重复值。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDQyNjc5Mg_size_16_color_FFFFFF_t_70 4]

1、sadd：添加一个或多个元素到集合中

redis127.0.0.1:6379> sadd mset 1 2 3 4

2、smembers：获取集合里面所有的元素

redis127.0.0.1:6379> smembers mset

3、srem：从集合中删除指定的一个或多个元素

4、spop：随机从集合中删除一个元素，并返回

5、scard：获取集合里面的元素个数

6、sdiff：返回集合1与集合2的差集。以集合1为主

redis127.0.0.1:6379> sdiff mset1 mset2

7、sinter：获得两个集合的交集

8、sunion：获得指定集合的并集

### 5) zset类型及操作 ###

zset是set的一个升级版本，它在set的基础上增加了一个顺序属性，这一属性在添加修改元素的时候可以指定，每次指定后，zset会自动重新按新的值调整顺序。可以理解为有两列的mysql表，一列存的value，一列存的顺序。操作中key理解为zset的名字。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDQyNjc5Mg_size_16_color_FFFFFF_t_70 5]

1、zadd：向一个指定的有序集合中添加元素，每一个元素会对应的有一个分数。你可以指定多个分数/成员组合。如果一个指定的成员已经在对应的有序集合中了，那么其分数就会被更新成最新的，并且该成员会重新调整到正确的位置，以确保集合有序。分数的值必须是一个表示数字的字符串。

redis127.0.0.1:6379> zadd zset 2 zhangsan 1 lisi 1 wangwu

2、zrange：返回有序集合中，指定区间内的成员。其中成员按照score（分数）值从小到大排序。具有相同score值的成员按照字典顺序来排列。

redis127.0.0.1:6379> zrange zset 0 -1 withscores

注: withscores返回集合中元素的同时，返回其分数（score）

3、zrem：删除有序集合中指定的值

redis127.0.0.1:6379> zrem zset zhangsan

4、zcard：返回有序集合元素的个数

### 6) 其他相关命令 ###

1、keys：按照键名查找指定的键。支持通配符（\* ?等）

redis127.0.0.1:6379> keys h*llo

2、exists：确认一个键是否存在（1表示存在）

3、del：删除一个键（通用）

4、expire：设置一个键（已存在）的过期时间，如果键已经过期，将会被自动删除

5、ttl：以秒为单位，返回指定键的剩余有效时间  
当 key 不存在时，返回 -2 。  
当 key 存在但没有设置剩余生存时间时，返回 -1 。  
否则，以秒为单位，返回 key 的剩余生存时间。

6、select：选择一个数据库，默认连接的数据库是0，可以支持共16个数据库。在配置文件中，通过databases 16 关键字定义。

7、move：将当前数据库的键移动到指定的数据库中

8、type：返回键的类型

9、dbsize：返回当前库中键的数量（所有类型）

10、save：保存所有的数据。很少在生产环境直接使用SAVE 命令，因为它会阻塞所有的客户端的请求，可以使用BGSAVE 命令代替. 如果在BGSAVE命令的保存数据的子进程发生错误的时,用 SAVE命令保存最新的数据是最后的手段。

11、info：获取服务器的详细信息

12、config get：获取redis服务器配置文件中的参数。支持通配符

13、flushdb：删除当前数据库中所有的数据

14、flushall：删除所有数据库中的所有数据

## 四、Redis 高级应用 ##

### 1) 密码防护 ###

给redis服务器设置密码

1、修改配置文件

# vi  /usr/local/redis/etc/redis.conf
    requirepass 123456

2、重启redis

# pkill redis
    # …/bin/redis-server …/etc/redis.conf

3、客户端登录

# …/bin/redis-cli -a 123456
    或
    交互模式下使用【auth密码】命令

### 2) 主从同步 ###

Redis主从复制过程：  
1、Slave与master建立连接，发送sync同步命令  
2、Master会启动一个后台进程，将数据库快照保存到文件中，同时master主进程会开始收集新的写命令并缓存。  
3、后台完成保存后，就将此文件发送给slave  
4、Slave将此文件保存到硬盘上

1、主服务器给自己设置好密码即可（iptables&SELinux关闭）

2、从服务器修改配置文件，用来连接主服务器  
老版本：  
从：

# slaveof <masterip> <msterport>      主服务器的IP和端口
    # masterauth <masterpass>           主服务器的密码(主服务器要设置好密码)

新版本redis 5.\* 以上：  
主：找到 bind 127.0.0.1 注释掉，或者修改为本机的IP地址(重启)  
从：

# replicaof <masterip> <msterport>   #主服务器的IP和端口
    # masterauth <masterpass>           #主服务器的密码(主服务器要设置好密码)

3、重启从服务器，然后测试（可通过info命令获取当前服务器身份类型）

### 3) 数据持久化 ###

Redis是一个支持持久化的内存数据库，也就是说需要经常将内存中的数据同步到硬盘来保证持久化。  
**snapshotting（快照）–默认方式**  
RDB持久化方式能够在指定的时间间隔能对你的数据进行快照存储。是默认的持久化方式。这种方式是将内存中数据以快照的方式写入到二进制文件中，默认的文件名为dump.rdb。这种持久化方式被称为快照 snapshotting（快照）。  
\# 过了900秒并且有1个key发生了改变 就会触发save动作  
\# 过了300秒并且有10个key发生了改变 就会触发save动作  
\# 过了60秒并且至少有10000个key发生了改变 也会触发save动作  
结论：在redis.conf文件中dir ./定义了数据库文件的存放位置，默认是当前目录。所以每次重启redis服务所在的位置不同，将会生成新的dump.rdb文件；建议服务器搭建完成时先修改快照文件保存位置。

**append-only file（缩aof）**  
使用AOF 会让你的Redis更加耐久: 你可以使用不同的持久化策略：每次写的时候备份、每秒备份、无备份。使用默认的每秒备份策略,Redis的性能依然很好(备份是由后台线程进行处理的,主线程会尽力处理客户端请求),一旦出现故障，你最多丢失1秒的数据。

打开redis.conf配置文件开启AOF持久化

appendonly no

默认不使用AOF持久化（450行）将no改成yes。

# appendfsync always

有写操作，就马上写入磁盘。效率最慢，但是最安全

appendfsync everysec

默认，每秒钟写入磁盘一次。

\# appendfsync no

不进行AOF备份，将数据交给操作系统处理。最快，最不安全

测试：重启redis服务，登录client添加一个键值，退出然后ls命令查看下是否生成appendonly.aof。可以用cat查看。

## 五、实验 MySQL+NoSQL(Redis) ##

1.安装 gcc\*

# yum -y install gcc*

2.安装所需要的包

# rz 		#上传 redis-mysql.zip
    # unzip redis-mysql.zip
    # cd redis-mysql
    # yum -y install *

3.配置网站nginx 并启动nginx

# vim /etc/nginx/conf.d/default.conf
    修改以下内容：
        location / {
        
            root   /usr/share/nginx/html;
            index  index.php index.html index.htm;			添加 index.php
        }
        location ~ \.php$ {
        		取消注释
            root           /usr/share/nginx/html;		指定网页目录
            fastcgi_pass   127.0.0.1:9000;
            fastcgi_index  index.php;
            fastcgi_param  SCRIPT_FILENAME  /usr/share/nginx/html$fastcgi_script_name;	指定网页目录
            include        fastcgi_params;
        }
    启动nginx
    # service nginx start

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDQyNjc5Mg_size_16_color_FFFFFF_t_70 6]

修改 nginx 运行主和组

# vim /etc/php-fpm.d/www.conf
    user = nginx
    group = nginx

![在这里插入图片描述][20210316001139208.png]

4.启动php和数据库

# service php-fpm start
    # service mysqld start

5.给 mysql 设置密码

# mysqladmin -uroot password 123456

6.测试网站和php的连通性，先在网页目录下写一个 index.php 文件

# vim /usr/share/nginx/html/index.php
    <?php
    phpinfo();
    ?>

浏览器测试  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDQyNjc5Mg_size_16_color_FFFFFF_t_70 7]

以上搭建了一个lnmp环境.

7.安装redis

# cd redis-mysql
    # tar -xf redis-2.8.19.tar.gz
    # cd redis-2.8.19
    # make && make PREFIX=/usr/local/redis install
    # cp redis.conf /usr/local/redis/

8.安装提供php和redis联系的软件

a. 解压

# cd /root/redis-mysql
    # unzip phpredis-master.zip

b. 安装

# cd phpredis-master
    # phpize
    # ./configure --with-php-config=/usr/bin/php-config && make && make install

c. 让php支持redis

# vim /etc/php.ini
    结尾添加内容：
    extension=redis.so
    # service php-fpm restart

![在这里插入图片描述][20210316001220304.png]

![在这里插入图片描述][20210316001240602.png]

9.进入 mysql 插数据

# mysql -uroot -p123456
    mysql> create database mytest;
    mysql> create table mytest.test(id int,name char(30));
    mysql> describe mytest.test;
    mysql> insert into mytest.test values(1,'laowang'),(2,'xingjiang'),(3,'wuyuzhe'),(4,'aoligei');
    mysql> select * from mytest.test；

10.开启 redis 后台运行，并编写脚本

# vim /usr/local/redis/redis.conf
    daemonize yes		# no 改为 yes ，意思是放入后台运行
    # /usr/local/redis/bin/redis-server /usr/local/redis/redis.conf		启动
    # /usr/local/redis/bin/redis-server shutdown		停止（有密码时需要指定密码  -a 123456 ）
    # vim /usr/share/nginx/html/redis-mysql.php
    <?php
    		ini_set("display_errors", "On");
    		error_reporting(E_ALL | E_STRICT);
    		//开启debug 
    	
    	
    		// mysql 库: mytest 表：test 
            $redis = new redis();
            $redis->connect('127.0.0.1',6379);
            $query = "select * from test limit 4";
            for ($key=1;$key<5;$key++)
            {
        
                    if (!$redis->get($key))
    				//判断redis中是否有1 2 3 4 5 的键，没有连接数据库查询mytest库的test表，然后插入到redis中
                    {
        
                            $connect = mysql_connect('127.0.0.1','root','123456');
                            mysql_select_db(mytest);
                            $result = mysql_query($query);
    						var_dump ($result);
                            while ($row = mysql_fetch_assoc($result))
                            {
        
                                    $redis->setex($row['id'],30,$row['name']);
    								//从MySQL中获取的资源插入到redis中，并设置有效时间为30s
                            }
                            $myserver = 'mysql';
                            break;
                    }
                    else
    				//判断redis中是否有1 2 3 4 5 的键，有直接打印redis中的 1 2 3 4 5 键的值。
                    {
        
                            $myserver = "redis";
                            $data[$key] = $redis->get($key);
                    }
            }
                            echo $myserver;
                            echo "<br>";
                            for ($key=1;$key<5;$key++)
                            {
        
                                    echo "number is <b><font color=#FF0000>$key</font></b>";
                                    echo "<br>";
                                    echo "name is <b><font color=#FF0000>$data[$key]</font></b>";
                                    echo "<br>";
                            }
    ?>

11.验证php访问redis 和 mysql

# /usr/local/redis/bin/redis-cli		客户端登录
    127.0.0.1:6379> FLUSHALL
    浏览器访问后
    127.0.0.1:6379> keys *
    127.0.0.1:6379> get 1

浏览器  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDQyNjc5Mg_size_16_color_FFFFFF_t_70 8]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDQyNjc5Mg_size_16_color_FFFFFF_t_70 9]

## 六、实验 Redis 主从同步 ##

### 主服务器 ###

#### 1、部署 Redis ####

# 下载 redis
    $ cd /server/tools && wget http://download.redis.io/releases/redis-3.2.12.tar.gz
    # 解压并进入目录
    $ tar xf redis-3.2.12.tar.gz && cd redis-3.2.12
    # 安装编译工具
    $ yum -y install gcc gcc-c++
    # 安装检查工具
    $ yum -y install tcl
    $ make && make PREFIX=/usr/local/redis install
    # 复制配置文件
    $ cp -a /root/redis-3.2.12/redis.conf /usr/local/redis/

#### 2、配置redis.conf文件 ####

# 配置主Redis配置文件
    $ vim redis.conf
    	bind 0.0.0.0		#代表所有地址
    	protected-mode no		#禁用保护模式（避免影响主从复制）
    	port 6379
    	daemonize yes		#后台运行
    	dir /usr/local/redis
    	requirepass 123456		#当前服务器的密码
    	appendonly yes       
      拷贝 Redis 配置文件，修改得到 6379 实例

#### 3、启动 Redis 服务 ####

# 启动服务
    $ ln -s /usr/local/redis/bin/* /usr/local/bin/
    $ redis-server /usr/local/redis/redis.conf
    # 登录测试
    $ redis-cli
    127.0.0.1:6379> keys *
    (empty list or set)
    127.0.0.1:6379> set name zhangsan
    OK
    127.0.0.1:6379> get name
    "zhangsan"
    127.0.0.1:6379> exit

### 从服务器 ###

#### 1、解压安装 ####

# 解压并进入目录
    $ tar xf redis-3.2.12.tar.gz && cd redis-3.2.12
    # 安装编译工具
    $ yum -y install gcc gcc-c++
    # 安装检查工具
    $ yum -y install tcl
    $ make && make PREFIX=/usr/local/redis install

#### 2、修改配置文件 ####

# 将 主服务器 的配置文件发送到 从服务器
    $ scp -r /usr/local/redis/ root@192.168.1.30:/usr/local/
    # 从服务器
    $ rm -rf appendonly.aof
    # 修改配置文件
    $ vim /usr/local/redis/redis.conf
    	slaveof 192.168.1.10 6379
    	masterauth 123456		#主服务器的密码

#### 3、启动服务 ####

$ ln -s /usr/local/redis/bin/* /usr/local/bin
    $ redis-server /usr/local/redis/redis.conf
    $ redis-cli
    127.0.0.1:6379> get name
    "zhangsan"
    127.0.0.1:6379> set name lisi
    (error) READONLY You can't write against a read only slave.
    # 从服务器只能读不能写，所以不能搭建 主主服务器

## 七、实验 Redis 集群 ##

1.基于 CRC16位算法存储数据

2.Redis 持久化方案  
RDB：根据定期时间或管理员命令，将内存数据持久化至磁盘的一种机制  
AOF：所有的数据修改操作写入操作先进行磁盘记录，再修改内存数据

#### 一、主机规划 ####

<table> 
 <thead> 
  <tr> 
   <th>主机</th> 
   <th>内网 IP 地址</th> 
   <th>端口</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>centos1.com</td> 
   <td>192.168.66.11</td> 
   <td>6378/6379</td> 
   <td>存储数据/主节点备份</td> 
  </tr> 
  <tr> 
   <td>centos2.com</td> 
   <td>192.168.66.12</td> 
   <td>6378/6379</td> 
   <td>存储数据/主节点备份</td> 
  </tr> 
  <tr> 
   <td>centos3.com</td> 
   <td>192.168.66.13</td> 
   <td>6378/6379</td> 
   <td>存储数据/主节点备份</td> 
  </tr> 
 </tbody> 
</table>

#### 二、部署 Redis ####

# 下载 redis
    $ cd /server/tools && wget http://download.redis.io/releases/redis-3.2.12.tar.gz
    # 解压并进入 src 目录
    $ tar xf redis-3.2.12.tar.gz && cd redis-3.2.12
    # 安装编译工具
    $ yum -y install gcc gcc-c++
    # 安装检查工具
    $ yum -y install tcl
    $ make && make PREFIX=/usr/local/redis install
    # 复制配置文件
    $ cp -a /root/redis-3.2.12/redis.conf /usr/local/redis/

#### 三、启动 Redis 服务 ####

##### 1、启动前优化内存分配策略 #####

$ echo 'vm.overcommit_memory=1' >>/etc/sysctl.conf && sysctl -p
    
    # Overcommit_Memory 参数可选值含义：
    #    0 表示内核将检查是否有足够的可用内存供应用进程使用；如果有足够的可用内存，内存申请允许；否则，内存申请失败，并把错误返回给应用进程
    #    1 表示内核允许分配所有的物理内存，而不管当前的内存状态如何
    #    2 表示内核允许分配超过所有物理内存和交换空间总和的内存

##### 2、启动 redis-server #####

# 启动服务
    $ redis-server /user/local/redis/conf/redis.conf &
    
    # 测试服务
    $ redis-cli

#### 四、构建 Redis-Cluster 集群 ####

**Redis Cluster 集群正常工作至少需要 3 个主节点，同时为了保证数据的高可用性，加入了主从模式。因此至少创建 6 个节点，一个主节点对应一个或多个从节点，主节点提供数据存取，从节点默认情况下只负责从 Master 拉取数据进行备份。当这个主节点挂掉后，集群就会通过下线检测的方式，由从节点中选举一个节点来充当主节点，实现故障转移，从而保证集群正常运行**

##### 1、创建存放多个实例的目录 #####

# 以单台主机为例，创建存放多个实例的目录
    $ mkdir -p /data/{
        6378,6379}

##### 2、配置redis.conf文件 #####

# 配置 6378 端口实例
    $ vim redis.conf
            port 6378
            daemonize yes
            pidfile /data/6378/redis.pid
            logfile /data/6378/redis.log
            loglevel notice
            dir /data/6378
            dbfilename dump.rdb
            #禁用保护模式（避免影响主从复制）
            protected-mode no
            #开启cluster模式
            cluster-enabled yes
            #记录集群信息，cluster集群自动维护，不用手动更新、创建
            cluster-config-file nodes.conf
            #节点超时时间，目标节点超过指定时间没响应，就标记为FAIL或PFAIL（可能宕机）
            cluster-node-timeout 5000
            appendonly yes
            bind 0.0.0.0
            
    # 拷贝 Redis 配置文件，修改得到 6379 实例

##### 3、启动 Redis 多实例 #####

# 启动 Redis 进程
    $ redis-server /data/6378/redis.conf 
    $ redis-server /data/6379/redis.conf 
    
    # 查看进程是否存在
    $ ps -ef|grep [r]edis
        root       2350      1  0 11:07 ?        00:00:01 redis-server *:6378 [cluster]
        root       2399      1  0 11:21 ?        00:00:00 redis-server *:6379 [cluster]

##### 4、创建 Redis Cluster 集群 #####

$ yum install ruby rubygems -y
    
    # 使用国内源
    $ gem sources --add http://mirrors.aliyun.com/rubygems/ --remove http://rubygems.org/
    
    # 检查源
        $ gem sources -l
        *** CURRENT SOURCES ***
        http://mirrors.aliyun.com/rubygems/
    
    # 安装依赖软件
    $ gem install redis -v 3.3.3
    
    # 创建一个包含三个主节点和三个从节点的集群
    $ cp /root/redis-3.2.12/src/redis-trib.rb /usr/local/redis/bin/
    
    # 
    $ redis-trib.rb create --replicas 1 192.168.66.11:6378 192.168.66.12:6379 192.168.66.13:6378  192.168.66.13:6379 192.168.66.14:6378 192.168.66.14:6379
    	- create：创建一个新的集群
    	- replicas：每个主节点创建一个从节点

##### 5、连接集群进行测试 #####

# 连接任一节点进行数据管理
    $ redis-cli -c -p 6378
    	192.168.66.11:6378> set msg 'oldboy'
    	-> Redirected to slot [6257] located at 172.16.1.57:6378
    		OK
    	192.168.66.11:6378> get msg
    		"oldboy"
    		
    		
    # 查看 key 对应的 slot
    $ cluster keyslot key
    
    # 查看 slot 和节点的对应关系
    $ cluster slots

#### 五、使用 Python 进行连接 Redis-Cluster 测试 ####

##### 1、安装 Python3.0 支持 #####

# 下载 python3.5.5 版本
    $ wget https://www.python.org/ftp/python/3.5.5/Python-3.5.5.tgz
    
    # 源码安装
    $ tar xf Python-3.5.5.tgz 
    $ cd Python-3.5.5/
    $ ./configure
    $ make && make install
     
    # 检查安装环境，这里使用 python3 命令，而不是 python 命令
    $ python3
    Python 3.5.5 (default, Apr 14 2019, 11:13:51) 
    [GCC 4.8.5 20150623 (Red Hat 4.8.5-16)] on linux
    Type "help", "copyright", "credits" or "license" for more information.
    >>> exit()

##### 2、安装 Redis-py 驱动 #####

# 下载源码包
    $ wget https://github.com/andymccurdy/redis-py/archive/2.10.6.tar.gz
    # 解压
    $ tar xf 2.10.6.tar.gz 
    # 切换到包目录下
    $ cd redis-py-2.10.6/
    # 安装驱动
    $ python3 setup.py install
    # 导入 redis 包，没有报错，驱动安装成功
    $ python3
        Python 3.5.5 (default, Apr 14 2019, 11:13:51) 
        [GCC 4.8.5 20150623 (Red Hat 4.8.5-16)] on linux
        Type "help", "copyright", "credits" or "license" for more information.
        >>> import redis
        >>>

##### 3、安装 Redis-py-cluster 驱动程序 #####

# 下载源码包
    $ https://github.com/Grokzen/redis-py-cluster/archive/1.3.6.tar.gz
    # 解压
    $ tar xf 1.3.6.tar.gz 
    # 切换到包目录下
    $ cd redis-py-cluster-1.3.6
    # 安装驱动
    $ python3 setup.py install

##### 4、使用代码测试 #####

from rediscluster import StrictRedisCluster
    #构建所有的节点
    startup_nodes = [
        {
        "host":"192.168.3.25", "port":6379},  # 主
        {
        "host":"192.168.3.25", "port":7001},  # 6379的从数据库
        {
        "host":"192.168.3.25", "port":6380},  # 主
        {
        "host":"192.168.3.25", "port":7002},  # 6380的从数据库
        {
        "host":"192.168.3.25", "port":6381},  # 主
        {
        "host":"192.168.3.25", "port":7003}   # 6381的从数据库
    ]
    #构建StrictRedisCluster对象
    redis_store= StrictRedisCluster(startup_nodes=startup_nodes, decode_responses=True)
    # 设置key键为name、money; value值为 '老鹰'、'10亿'
    redis_store.set('name', '老鹰')
    redis_store.set('money', '10亿')
    # 获取键为name,money
    print("My name is: ", redis_store.get('name'))
    print("I have money: ", redis_store.get('money'))

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDQyNjc5Mg_size_16_color_FFFFFF_t_70]: /images/20221023/9cd303db09cb46569543d177c07aa239.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDQyNjc5Mg_size_16_color_FFFFFF_t_70 1]: /images/20221023/329a6ecf0bf646628b7a97f660663357.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDQyNjc5Mg_size_16_color_FFFFFF_t_70 2]: /images/20221023/8d1302e7ddd44240a2fe26ebac4cfb99.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDQyNjc5Mg_size_16_color_FFFFFF_t_70 3]: /images/20221023/995ba502cfcf408f8b61ed7acdc36f24.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDQyNjc5Mg_size_16_color_FFFFFF_t_70 4]: /images/20221023/6f21a8d2b8f74f1fb21575e0e78a27ef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDQyNjc5Mg_size_16_color_FFFFFF_t_70 5]: /images/20221023/dccd6905155446edb3ceb01fd9fd5bbc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDQyNjc5Mg_size_16_color_FFFFFF_t_70 6]: /images/20221023/7b5ca151470d4358857f2d418c3b894a.png
[20210316001139208.png]: /images/20221023/f4559f35b3a24eb3b276d241d042cf0a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDQyNjc5Mg_size_16_color_FFFFFF_t_70 7]: /images/20221023/fa89401095e944e3ba25002240677d88.png
[20210316001220304.png]: /images/20221023/33f30710ee924907bedc39a3c9ab5388.png
[20210316001240602.png]: /images/20221023/8440fbfb5fc64a8a9ca0af212fe497be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDQyNjc5Mg_size_16_color_FFFFFF_t_70 8]: /images/20221023/ebb3c16ce6114c0384c3071efd058dd9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDQyNjc5Mg_size_16_color_FFFFFF_t_70 9]: /images/20221023/f7faf5858dcb496fb41b9449fe74432c.png