mariadb的主从复制，redis的主从复制，redis哨兵，redis集群。

1 mysql基本命令

1.启动mysql
systemctl start mariadb
​
2.linux客户端连接自己 
mysql -uroot -p -h 127.0.0.1
​
3.远程链接mysql服务端：
    条件一：两台机器上都安装了mysql （mariadb）
    条件二：远程授权
    远程授权:
    grant all privileges on *.* to root@"root"@'10.0.3.191' indentified by '123456';
    flush privileges
远程连接的sql语句：
    mysql -uroot -p123456 -h 10.0.3.189
​
​
4.修改mysql密码
MariaDB [(none)]> set password = PASSWORD('redhat123');
​
5.创建mysql用户
create user xiaochun@'%' identified by 'xc666';
​
6.查询mysql库中的用户信息
use mysql;
select host,user,password from  user;
​
7.授权语句
给李俊这个用户，授予创建数据库的权限
​
mysql使用grant命令对账户进行授权，grant命令常见格式如下
​
grant 权限 on 数据库.表名 to 账户@主机名            对特定数据库中的特定表授权
grant 权限 on 数据库.* to 账户@主机名            　　对特定数据库中的所有表给与授权
grant 权限1,权限2,权限3 on *.* to 账户@主机名   　　 对所有库中的所有表给与多个授权
grant all privileges on *.* to 账户@主机名   　　 对所有库和所有表授权所有权限
​
#授予小春创建的权限，对于所有的库表生效
grant create  on *.* to xiaochun@"%"  identified by 'xc666';
#授予小春用户，只有创建mymysql数据库的权限
grant create  on mymysql.* to xiaochun@"%"  identified by 'xc666';
​
#授予用户最大的权限，所有的权限
grant all privileges on *.* to username@'%' identified by 'password';
​
​
8.移除权限
MariaDB [(none)]> revoke all privileges on *.* from xiaochun@"%" identified by 'xc666';
​
​
9.数据库的备份与恢复
#备份
mysqldump -u root -p --all-databases > /tmp/db.sql
#数据导入，方式有2种
source /tmp/db.sql;
​
第二种
mysql -uroot -p <  /tmp/db.sql 
​
​
第三种
navicat
​
第四种，如果你数据量特别大的话，使用第三方工具
xtrabackup

 

2 mariadb主从复制

主从复制7步曲:
1. 主数据库写入数据之后， 会有data changes(数据变化)记录
2. 有变化记录之后，将增删改的一些sql语句记录到本地的Binary log(二进制日志)中
3. 从库会一直开启着一个线程
4. 通过线程去读取这个二进制日志的内容
5. 从库会将数据写入到自己的Relay log(中继日志)中
6. 从库会将中继日志中的操作转化为SQL thread(SQL语句)
7. 通过转化的SQL语句写入到自己的数据库, 两边的数据就一致了

 

3 mariadb主从复制实验

3.1 需求:

准备两台数据库服务器

主服务器： 10.0.3.156
从服务器:  10.0.3.212

3.2 在主服务器上操作

3.2.1 停止主服务器mariadb数据库服务

systemctl stop mariadb

3.2.2 修改主服务器配置文件

[mysqld]
server-id=1
log-bin=qishi-logbin

3.2.3 启动mariadb

systemctl start mariadb

3.2.4登录mariadb，新建用于主从同步的用户lijun,允许登录的从库是'192.168.12.249'

create user 'lijun'@'%' identified by 'lj666';

3.2.5.给从库账号授权,说明给lijun从库复制的权限，在192.168.12.249机器上复制

grant replication slave on *.* to 'lijun'@'%';

3.2.6 检查主库创建的复制账号

select user,host from mysql.user;

3.2.7 检查授权账号的权限

show grants for lijun@'%';

3.2.8 实现对主数据库锁表只读，防止数据写入，数据复制失败

flush table with read lock;

3.2.9 检查主库的状态, 并记录下日志文件的名字，和位置

MariaDB [(none)]> show master status;

记录下主数据库的写入状态和日志文件的名字

3.2.10 锁表后，一定要单独再打开一个SSH窗口，导出数据库的所有数据，

注意，一定要单独再打开一个SSH窗口！！！！！

注意，一定要单独再打开一个SSH窗口！！！！！

注意，一定要单独再打开一个SSH窗口！！！！！

3.2.11 退出数据库，在主机库上导出数据

mysqldump -u root -p --all-databases > /opt/qishimaster.sql

3.3 在从库上配置

3.3.1 关闭数据库服务

systemctl stop mariadb

3.3.2 在从库10.0.3.212上打开/etc/my.cnf

如果从库是新安装的数据库的话，没有中文配置，还需要添加中文配置

[mysqld]
character-set-server=utf8
collation-server=utf8_general_ci
log-error=/var/log/mysqld.log
​
server-id=3
read-only=true
​
[client]
default-character-set=utf8
[mysql]
default-character-set=utf8

3.3.3 重启数据库

systemctl restart mariadb

3.3.4 将主库导出的数据库文件拷贝到从库中

scp 192.168.12.249:/opt/qishimaster.sql /opt/

3.3.5 导入主库传过来的数据库文件，保持从库的数据与主库一致

mysql -u root -p
source /opt/qishimaster.sql

3.3.6 配置复制的参数，Slave从库连接Master主库的配置

MariaDB [oldboy] > change master to master_host='10.0.3.189',
                -> master_user='ritian',
                -> master_password='123456',
                -> master_log_file='oldboy-logbin.000001',
                -> master_log_pos=472;

3.3.7 启动从库的同步开关，测试主从复制的情况

start slave;
​

3.3.8 查看复制状态

show slave statusG;

注意： 如果看到Slave_IO_Running和Slave_SQL_Running这两个参数都为yes, 说明主从同步配置成功，否则需要检查并重新配置

如果发现有问题的话，建议推倒重来(最好是恢复快照)

3.4 最后在主库上操作

3.4.1 登录主机数据库，解锁主库的写入

unlock tables;

3.4.2 如果从库上面的普通用户无法在从库上登录，就重新创建一个用户

create user 'yatai'@'%' identified by 'yt666';
grant replication slave on *.* to 'yatai'@'%';

或者在主库上给zhengge授权, 只能授于查看的权限

grant select on *.* to lijie@"%" identified by "lj666";

3.4.3 验证主从读写分离的效果如图显示

 

4. 发布订阅

4.1 发布者 PUBLISH 发送消息

 publish channel 消息

4.2订阅者 SUBSCRIBE 订阅消息

 等待发送者，向管道发送消息
 subscribe channel channel2 channel3 

4.3 频道 channel

 自定义频道的名字

4.4 支持正则的频道订阅

 psubscribe 支持正则的频道
 publish channel 消息

 

5. redis持久化

5.1 redis特性

redis是内存型的数据库

redis数据放在内存中
重启服务器丢失数据
重启redis服务丢失数据
断电丢失数据

为了防止redis数据丢失，进行持久化，所以将数据写入到一个文件中来实现

5.2 RDB持久化

5.2.1.在配置文件中，添加rdb持久化参数

redis-6379.conf

写入如下配置

port 6379     
daemonize yes     
pidfile /data/6379/redis.pid
loglevel notice  
logfile "/data/6379/redis.log"
dir /data/6379   
protected-mode yes 
dbfilename dbmp.rdb
​
# 定时创建数据快照机制
save 900 1                       # rdb机制 每900秒 有1个修改记录
save 300 10                      # 每300秒  10个修改记录
save 60 10000                    # 每60秒内  10000修改记录

注意: 修改完配置之后，需要重启redis服务

5.2.2.触发rdb持久化，可以手动save命令即可,生成 dump.rdb持久化文件

5.2.3.重启redis，数据不再丢失

5.2.4.rdb数据文件是二进制文件，人为的看不懂

5.3 AOF持久化

5.3.1.在配置文件中，添加aof参数

在redis-6379.conf中添加参数，开启aof功能

appendonly yes
appendfsync everysec

5.3.2.重启redis数据库，加载aof功能

5.4 redis持久化RDB转化AOF

5.4.1 删除现有的aof文件，备份RDB文件

cd /data/6379
rm -rf appendonly.aof
cp qishi5.rdb qishi5.rdb.bak

5.4.2 配置RDB切换到AOF

# 先进入redis客户端
redis-cli

# 配置开启AOF
127.0.0.1:6379> config set appendonly yes
# 关闭RDB
127.0.0.1:6379> config set save ""

5.4.3 以上配置重启后会失效，如果需要永久将RDB切换到AOF, 还是需要修改配置文件才可以

redis进阶

1. redis主从同步

1.1 redis主从同步原理

原理：

1. 从服务器向主服务器发送 SYNC 命令。

2. 接到 SYNC 命令的主服务器会调用BGSAVE 命令，创建一个 RDB 文件，并使用缓冲区记录接下来执行的所有写命令。

3. 当主服务器执行完 BGSAVE 命令时，它会向从服务器发送 RDB 文件，而从服务器则会接收并载入这个文件。

4. 主服务器将缓冲区储存的所有写命令发送给从服务器执行。

------------- 1、在开启主从复制的时候，使用的是RDB方式的，同步主从数据的 2、同步开始之后，通过主库命令传播的方式，主动的复制方式实现 3、2.8以后实现PSYNC的机制，实现断线重连

2. redis主从同步实验

2.1 准备三个redis数据库配置文件

背景： 一主两从

6380为主，6381和6382 为从

cd /opt/redis_conf
vim redis-6380.conf
写入以下配置
port 6380
daemonize yes
pidfile /data/6380/redis.pid
loglevel notice
logfile "/data/6380/redis.log"
dbfilename dump.rdb
dir /data/6380
protected-mode no

再创建两个配置文件6381和6382

sed "s/6380/6381/g" redis-6380.conf > redis-6381.conf
sed "s/6380/6382/g" redis-6380.conf > redis-6382.conf

创建数据文件目录

[root@qishi666 redis_conf]# mkdir -p /data/6380
[root@qishi666 redis_conf]# mkdir -p /data/6381
[root@qishi666 redis_conf]# mkdir -p /data/6382

2.2 启动redis数据库

[root@qishi666 redis_conf]# redis-server redis-6380.conf 
[root@qishi666 redis_conf]# redis-server redis-6381.conf 
[root@qishi666 redis_conf]# redis-server redis-6382.conf

2.3 确保这三个redis数据库是完全独立的数据库

2.4 给两个从服务器配置文件再添加一行配置(很重要)

在6381和6382配置文件添加这一行配置，表示指定主服务器为6380
slaveof 127.0.0.1 6380

2.5 重启数据库

pkill redis
redis-server /opt/redis_conf/redis-6380.conf
redis-server /opt/redis_conf/redis-6381.conf
redis-server /opt/redis_conf/redis-6382.conf

2.6 查看主从数据库状态

redis-cli -p 6380 info
redis-cli -p 6380 info replication

2.7 添加数据进行测试

在从服务器上不可以写入，原因是因为:

2.8 手动进行主从复制故障切换

2.8.1 关闭6381的从库身份

redis-cli -p 6381
info replication
slaveof no one

2.8.2 将6382设为6381的从库

6382连接到6381：
[root@db03 ~]# redis-cli -p 6382
127.0.0.1:6382> SLAVEOF no one
127.0.0.1:6382> SLAVEOF 127.0.0.1 6381

 

3. redis哨兵

3.1 sentinel主要功能如下：

• 不时的监控redis是否良好运行，如果节点不可达就会对节点进行下线标识

• 如果被标识的是主节点，sentinel就会和其他的sentinel节点“协商”，如果其他节点也认为主节点不可达，就会选举一个sentinel节点来完成自动故障转义

• 在master-slave进行切换后，master_redis.conf、slave_redis.conf和sentinel.conf的内容都会发生改变，即master_redis.conf中会多一行slaveof的配置，sentinel.conf的监控目标会随之调换

3.2 redis sentinel配置步骤

3.2.1 配置三个redis数据库, 一主两从

redis-6380.conf
redis-6381.conf
redis-6382.conf

3.2.2 启动三个redis数据库，确保主从复制正常运行

redis-server redis-6380.conf
redis-server redis-6381.conf
redis-server redis-6382.conf

redis-cli -p 6380 info replication
redis-cli -p 6381 info replication
redis-cli -p 6382 info replication

3.2.3 配置三个哨兵

cd /opt/redis_conf
vim redis-sentinel-26380.conf
vim redis-sentinel-26381.conf
vim redis-sentinel-26382.conf

写入以下配置文件

port 26380
dir /data/26380
logfile "26380.log"
sentinel monitor qishimaster 127.0.0.1 6380 2
sentinel down-after-milliseconds qishimaster 60000
sentinel parallel-syncs qishimaster 1
sentinel failover-timeout qishimaster 180000
daemonize yes
​

vim中的替换：

%s/qishimaster/qishi8master/g  # 进行替换主服务器的别名

哨兵配置文件详解:

# Sentinel节点的端口
port 26379  
dir /var/redis/data/
logfile "26379.log"
​
# sentinel announce-ip 127.0.0.1   # 宣告哨兵IP, 此配置只有当使用非127.0.0.1的IP配置哨兵无法成功时加上，同时redis三个服务端也需要同步修改IP
​
# 当前Sentinel节点监控 127.0.0.1:6380 这个主节点
# 2代表判断主节点失败至少需要2个Sentinel节点节点同意
# mymaster是主节点的别名
# monitor 是监控
sentinel monitor mymaster 127.0.0.1 6380 2
​
# 每个Sentinel节点都要定期PING命令来判断Redis数据节点和其余Sentinel节点是否可达，如果超过30000毫秒30s且没有回复，则判定不可达
sentinel down-after-milliseconds mymaster 30000
​
# 当Sentinel节点集合对主节点故障判定达成一致时，Sentinel领导者节点会做故障转移操作，选出新的主节点，原来的从节点会向新的主节点发起复制操作，限制每次向新的主节点发起复制操作的从节点个数为1
sentinel parallel-syncs mymaster 1
​
# 故障转移超时时间为180000毫秒
sentinel failover-timeout mymaster 180000
​
daemonize yes

创建三个哨兵配置的文件

sed 's/26380/26382/g' redis-sentinel-26380.conf>redis-sentinel-26382.conf 

创建存放哨兵文件的目录

mkdir -p /data/{26380,26381,26382}

如果发现哨兵没有正常启动，必须把IP改为127.0.0.1

如果你是在三个不同的机器上，只能用机器对外访问的IP，那就需要添加这一个配置

sentinel announce-ip 127.0.0.1

3.2.4 启动三个哨兵

[root@qishi666 redis_conf]# redis-sentinel redis-26380.conf
[root@qishi666 redis_conf]# redis-sentinel redis-26381.conf
[root@qishi666 redis_conf]# redis-sentinel redis-26382.conf

3.2.5 此时查看哨兵是否成功通信

3.2.6 如果出现问题，没有配置成功，没有显示前面这几条配置成功的信息，就推倒重来

如果出现问题，没有配置成功，没有显示前面这几条配置成功的信息，就推倒重来!!!!!!

如果出现问题，没有配置成功，没有显示前面这几条配置成功的信息，就推倒重来!!!!!!

从配置主从同步开始做!!!!!

3.2.7 验证redis高可用故障切换

大致思路

• 杀掉主节点的redis进程6380端口，观察从节点是否会进行新的master选举，进行切换

• 重新恢复旧的“master”节点，查看此时的redis身份

首先查看三个redis的进程状态

再把6380启动起来，查看他们的主从状态

 

4 redis集群概念

4.1 为什么需要用到集群

全量数据， 量很大，一台机器没有办法全部处理完，所以需要多台机器同时处理，才能达到我们想要的效果

就类似于一大车货物，通过5辆马车来运输

4.2 redis集群槽位概念

虚拟槽分区巧妙地使用了哈希空间，使用分散度良好的哈希函数把所有的数据映射到一个固定范围内的整数集合，整数定义为槽（slot）。

Redis Cluster槽的范围是0～16383。

槽是集群内数据管理和迁移的基本单位。采用大范围的槽的主要目的是为了方便数据的拆分和集群的扩展，

每个节点负责一定数量的槽。

 

4. redis集群配置

4.1 准备六个节点

cd /opt/jq
vim redis-7000.conf
vim redis-7001.conf
vim redis-7002.conf
vim redis-7003.conf
vim redis-7004.conf
vim redis-7005.conf

写入配置

port 7000
daemonize yes
dir "/data/jq/7000"
logfile "7000.log"
dbfilename "dump-7000.rdb"
cluster-enabled yes
cluster-config-file nodes-7000.conf

这6个节点配置文件都一样，仅仅是端口的不同

[root@qishi666 jq]# sed "s/7000/7001/g" redis-7000.conf > redis-7001.conf
[root@qishi666 jq]# sed "s/7000/7002/g" redis-7000.conf > redis-7002.conf
[root@qishi666 jq]# sed "s/7000/7003/g" redis-7000.conf > redis-7003.conf
[root@qishi666 jq]# sed "s/7000/7004/g" redis-7000.conf > redis-7004.conf
[root@qishi666 jq]# sed "s/7000/7005/g" redis-7000.conf > redis-7005.conf

创建这六个节点的文件目录

mkdir -p /data/jq/{7000,7001,7002,7003,7004,7005}

4.2 启动这六个节点

cd /opt/jq
redis-server redis-7000.conf
redis-server redis-7001.conf
redis-server redis-7002.conf
redis-server redis-7003.conf
redis-server redis-7004.conf
redis-server redis-7005.conf

4.3 随便进入一个redis交互模式，写入数据，发现无法写入

报错，没有分配哈希槽

4.4 准备ruby环境，安装ruby并执行redis-trib.rb脚本

分配redis集群状态，以及槽位分配，互联网企业，豆瓣公司开源的一个工具

1 下载、编译、安装Ruby

# 下载ruby
wget https://cache.ruby-lang.org/pub/ruby/2.3/ruby-2.3.1.tar.gz
​
# 安装ruby
tar -xvf ruby-2.3.1.tar.gz
cd ruby-2.3.1/
./configure --prefix=/opt/ruby/
make && make install

4.5 配置ruby环境

4.5.1 配置ruby环境变量

vim /etc/profile

在PATH=后面添加ruby的环境变量路径

PATH=/opt/ruby/bin:/opt/python36/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/root/bin

4.5.4 安装redis-trib.rb命令

当然，这一步并不是必须的，你可以找到redis的安装目录/opt/redis/src下,去执行这个脚本

cp /opt/redis/src/redis-trib.rb /usr/local/bin/

 

4.6 安装ruby gem 包管理工具

4.6.1 下载gem包

wget http://rubygems.org/downloads/redis-3.3.0.gem

4.6.2 安装

gem install -l redis-3.3.0.gem

4.7 一键开启redis-cluster集群

4.7.1 一条命令开启集群

redis-cli --cluster create --cluster-replicas 1 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 127.0.0.1:7003 127.0.0.1:7004 127.0.0.1:7005
​
# 每个主节点，有一个从节点，代表--replicas 1
# 集群自动分配主从关系  7000、7001、7002为主 7003、7004、7005为从

4.7.2 查看集群状态

4.8 进入集群状态

redis-cli -p 7000 -c