Mariadb/Redis数据库

mariadb ---磁盘型数据库

基础安装

配置好yum源后,软件就可以通过配置的yum源进行安装,按理来讲安装mysql直接通过   yum install mariadb  -y  便可安装,但是再企业中通过配置的阿里云的两个源版本太低,因此会使用mariadb官方提供的yum源,下载官方的mariadb包

实现远程连接

• 进入yum仓库,    /etc/yum.repos.d 目录下,手动创建一个 mariadb.repo文件

  #写入如下信息
  [mariadb]
  name = MariaDB
  baseurl = http://yum.mariadb.org/10.1/centos7-amd64
  gpgkey = https://yum.mariadb.org/RPM-GPG-KEY-MariaDB
  gpgcheck = 1

  执行 yum install mariadb        #这是下载mariadb的yum源就变成了官方的源    

• 安装成功后启动mariadb             systemctl start mariadb
• mariadb初始化              mysql_secure_installation  
• 修改数据库编码

  #中文编码设置,编辑mysql配置文件  /etc/my.conf  写入以下代码
  
  [mysqld]
  character-set-server=utf8
  collation-server=utf8_general_ci
  log-error=/var/log/mysqld.log
  

    datadir=/var/lib/mysql
    socket=/var/lib/mysql/mysql.sock

  
  [client]
  default-character-set=utf8
  [mysql]
  default-character-set=utf8

    [mysqld_safe]
    log-error=/var/log/mariadb/mariadb.log
    pid-file=/var/run/mariadb/mariadb.pid

• 远程连接数据库

  首先进入数据库   mysql -uroot -p +密码
  1.#创建普通用户
      create user son1@'%' identified by 'son123';
  
  2.#对用户授权，给予root用户远程登录的权限
      grant all privileges on *.* to root@"%" identified by  "redhat123";
  
  3.#立即刷新授权表
      flush privileges;

  这样便可以远程连接linux服务器了...

 基础使用

 -- 1 备份mysql数据

1.执行导出数据库命令

mysqldump -u root -p --all-databases > /tmp/db.dump
# --all-databases导出所有数据库  写入tmp下的db.dump文件中

#也可以指定的导出数据库

　#指定crm数据库导出
　#mysqldump -uroot -p --database crm > /tmp/ace_crm.dump

2.进入数据库删掉你不顺眼的库;嘿嘿...比如你的项目..  

3.执行导入数据库命令

1.    mysql -u root -p < /tmp/db.dump
#导入数据库信息
2.  source   /tmp.db.dump
#注意!!!这条命令是在数据库中执行,同步数据库原先你删掉的项目  哈哈,咱不慌...

--2 mysql的主从复制

1.环境准备

主库配置如下:

主库配置:编辑mysql的配置文件    vim /etc/my.cnf
1.写入如下内容
[mysql]
server-id=1
log-bin=s17-mysql-bin

2.创建一个用于同步的用户

create user 'son'@'%' identified by '123';

3.给予这个账号,一个从的身份

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

4.导出当前数据库的数据,发送给从库,进行导入
mysqldump -u root -p --all-databases > /tmp/db.dump

5.发送主库的mysql数据,给从库
scp /tmpdb.dump root@从库ip地址+端口号

从库操作如下:

1.编辑从库的mysql配置文件,写入一个身份id号,区别于主库, vim /etc/my.cnf

写入主机身份id    server-id =10       # 任意不和主库server-id重复的id号

2.通过一条命令,确保主从成功

#在从库执行这条SQL命令中

change master to master_host='主库ip地址',
master_user='主库名',
master_password='主库密码',
master_log_file='s17-mysql-bin.000001',   #主库文件
master_log_pos=1510;   #主库的数据的起始点

3.开启slave同步

#在从库中执行这条SQL命令

start alave;

4.检查主从同步是否正常

#在从库中执行SQL命令
    show slave statusG;

5.然后可以测试往主库写入数据,查看从库数据 

 -----------------------------------------------------------------------------------------------------------

redis ---内存型数据库

数据存储在内存中,kv数据库系统,服务器断电,进程退出,数据丢失,所以需要做数据持久化,用途,微信红包/微博点赞/关注度,淘宝的首页的轮播图热数据,等等都是存在redis中,性能极高,每秒钟10W次读写,微博评论等高吞吐量数据能够支撑,同时新浪微博是用redis,全世界用redis集群最大的公司

基础安装

1.查看你是否先前安装过redis,如果有,卸载通过yum安装的redis数据库

yum remove redis -y

2.通过编码编译安装

• 下载redis的源代码

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

• 解压源代码

  tar -zxf redis-4.0.10.tar.gz

• 进入redis源码目录,编译安装,生成可执行命令   注意:redis不需要执行configure,因为他已经生成了makefile
• 执行  make && make install
• 此时已经可以正常启动redis服务端了

3.安全性能下启动redis,  在redis.conf中,更改默认端口,添加密码,开启安全模式

#当然先麻烦的话也可以手动创建一个redis的配置文件

touch  about_redis.conf
写入以下配置信息
[root@master redis-4.0.10]# cat about_redis.conf 
bind 0.0.0.0
protected-mode yes
port 6999
daemonize yes
requirepass  hehe
     

4.启动redis服务端,指定配置文件

　　redis-server about_redis.conf

5.测试访问redis服务端

#测试访问服务端
redis-cli -p 6999

进入后通过auth指令进行redis密码验证,验证通过后  发送ping,得到pong指定后代表redis正常

redis数据结构以及常用命令

redis是一种高级的key:value存储系统,其中value支持5种数据类型

字符串  --- strings

散列 --- hashes

列表 --- lists 

集合 --- sets

有序集合 ---sorted sets

 基本命令

keys *    #查看所有的key

type key    #查看key的类型

expire key seconds     # key过期时间

ttl key    #查看key的过期时间   -2表示key不存在了

persist key   #取消key的过期时间 -1表示key还在,没有过期时间

exsits key   #判断key是否存在, 存在返回1 否则0

dbsize      # 查看有多少个key   返回数字

del  keys    #删除key,可删除多个key

strings类型

set 　　#设置key

get   #获取key

append  #追加string    
    #例如 set you 'sb'
    append  you  '250' 
    get  you     #显示"sb250"   

mset    # 设置多个键值对
    #mset  food1 'apple' food2 'banana' food3  'orange'

mget   #获取多个键值对
   #mget  food1  food2  food3      #'apple' 'banana' 'orange' 
del key       #删除key
incr    #递增+1  一般用于点赞+1
decr   #递减-1  取关

lists类型

lpush   #向列表左侧插入
rpush   #向列表右侧插入

lrange  #获取一定长度的元素 lrange key  start  end
# lrange  key  0 -1  #获取全部元素

lpop   # 删除最左侧列表元素
rpop  #删除最右侧列表元素

lpushx /rpushx      #key 存在添加,否则不作处理

sets集合类型(无序去重) 

sadd    key  '元素' # 创建一个集合

smembers  key  #查看集合

sismember key  ''元素''   #查看集合中的元素是否存在,返回0,1

sadd  family  'father' 'mother' 'sister'
sadd  family2  'mother' 'bother' 'son'

#如上创建了两个集合family  family2

sdiff  family  family2     #找出family有的,family2没有的      也就是father sister

sdiff family2  family    #找出family2有的,family 没有的   也就是 'bother' 
 'son'

sinter  family family2    #找出两个集合里都有的   mother

sunion  family family2   #找出两个集合里所有不重复的元素    'father' 'mother' 'sister'  'bother' 'son'

 有序集合类型

都是z开头的命令,用来保存成绩,工资,价格等...

zadd   #有序集合
#有序集合查看价格表
zadd  price_list    8888   iPhoneX
zadd  price_list    1   latiao
zadd  price_list    10 book

ZREVRANGE  price_list   0 -1 withscores    #倒序价格排列

1) "iPhoneX"
2) "8888"
3) "book"
4) "10"
5) "latiao"
6) "1"

ZRANGE   price_list   0 -1 withscores  #正序价格排列
1) "latiao"
2) "1"
3) "book"
4) "10"
5) "iPhoneX"
6) "8888"

ZREM  price_list  latiao    #移除有序集合中的latiao元素

ZCARD price_list     #返回有序集合中的元素计数

ZSCORE  price_list   book    #返回集合里面书的价格

 哈希数据结构

哈希结构就是字典套字典结构, k1:{'k2':v2,'k3':v3}  ,哈希结构是redis-2.0.0版本才有的数据结构

hset book title  'mood'   #设置book 对应的key title的值是"mood"
hset book content  'happy'  #添加一个key content  值是 'happy'

hget book title/content   #获取 title/content的内容

hmget  book title content   #获取多个key的值

hmset  book1 title "status" content "nice"  #同时设置多个字段

hkeys book1     #获取book1所有的key

hvals book    #获取book中key对应的所有的值

hlen book   #查看book的可以的数量

hexists  book  title    #查看book中的key是否存在,返回0,1

Redis的发布订阅

 redis的发布订阅就像一个广播系统,多个收听者可以订阅电台的多个广播频道,例如QQqun,OA群聊等,redis支持在一台机器上运行多个实例数据库,

SUBSCRIBE      #订阅
    #SUBSCRIBE   xiaojiejie       订阅一个xiaojiejie的频道
    #PSUBSCRIBE python*        订阅一个跟所欲python开头相关的频道
    

PUBLISH    #将 信息发送到指定的频道

    PUBLISH xiaojiejie  nice      #向xiaojiejie频道发送nice


#可以同时开多个redis客户端,模拟一个电台向多个频道发送信息

reids的持久化---RDB模式和AOF模式 

什么是redis的持久化呢?

由于redis是一种内存型数据库,一旦服务器进程退出或断电,数据库的数据就会丢失,为了解决这个问题,redis提供了两种持久化的方案,将内存中的数据保存在磁盘中,避免数据的丢失.

 RDB模式

将redis的内存状态保存到硬盘中,它可以进行手动执行,也可以对redis.conf中配置,定期执行,RDB持久化产生的RDB文件是一个经过压缩的二进制文件,这个文件保存在硬盘中,redis通过这个文件还原数据库当时的状态

操作步骤:

1.准备一个redis配置文件,rdbredis.conf,写入如下内容

daemonize yes                 #后台运行
port 6379
logfile /data/6379/redis.log
dir /data/6379/                #指定持久化文件存储位置
dbfilename  dbmp.rdb          #rdb持久化文件
bind 0.0.0.0                  #redis绑定地址
requirepass 123               #redis登录密码
save 900 1                    #rdb机制 每900秒 有1个修改记录
save 300 10                    #每300秒        10个修改记录
save 60  10000                #每60秒内        10000修改记录

当然先创建持久化文件目录 mkdir -p /data/6379,还有复制这些参数的时候不要有中文!!!

2.启动redis服务端    redis-server rdbredis.conf

AOF模式   不需要手动的save 触发持久化

步骤:

1.准备一个redis配置文件,aofredis.conf

#写入如下内容  
daemonize yes
port 6379
logfile /data/6379/redis.log
dir /data/6379
appendonly yes    #开启aof持久化的参数，就是这个
appendfsync everysec        #每秒进行一次aof持久化

2. 支持aof方式的额持久化

　　　　redis-server  aofredis.conf 

3.验证aof持久化,写入数据后,杀死进程,再次启动redis检查数据.

在不重启的情况下,切换rdb数据到aof模式下

1.环境准备,准备一个rdb的redis数据库,并且是2.0版本以上的

2.登录此时的rdb数据库,通过两条命令,临时修改切换到aof模式下,也是把rdb数据转化为aof模式

127.0.0.1:6379> CONFIG set appendonly yes   #开启AOF功能
OK
127.0.0.1:6379> CONFIG SET save ""  #关闭RDB功能
OK

3.此时还是临时生效,必须修改配置文件,永久生效,配置文件修改如下

[root@master redis-4.0.10]# cat rdbredis.conf 
daemonize yes       
port 6379           
logfile /data/6379/redis.log
dir /data/6379/         
bind 0.0.0.0
appendonly yes    
appendfsync everysec   

这样就可以了....无缝切换

redis主从同步机制

1.环境准备,准备3个redis数据库实例   准备3个redis配置文件即可.

redis-6379.conf 

port 6379
daemonize yes
pidfile /data/6379/redis.pid
loglevel notice
logfile "/data/6379/redis.log"
dbfilename dump.rdb
dir /data/6379




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
SLAVEOF 127.0.0.1  6379
#记得先创建pidfile的目录   mkdir /data/6380    
    


redis-6381.conf 

port 6381
daemonize yes
pidfile /data/6381/redis.pid
loglevel notice
logfile "/data/6381/redis.log"
dbfilename dump.rdb
dir /data/6381
SLAVEOF 127.0.0.1  6379

#还有   mkdir /data/6381  

2.分别启动三个数据库,进入客户端模式

3.此时已经生成一主两从的身份了

4.此时可以演示在主库里写入数据,从库读取数据

手动切换中从同步的故障(当主库挂掉的时候,怎么办)

1.模拟主库挂掉,kill杀死主库的进程

2.此时两个从库不知所措.....

3,手动切换两个从库的身份,让其中一个为新的master,选举6381为新的master,只需要在6381下输入slaveof on one,然后配置6380为新的slave,只需要在6380下输入slaveof 127.0.0.1 6381

4.此时的一主一从就ok了 主库6381  从库6380

5.测试写入数据,万事大吉!!!

redis-sentinel(哨兵)

简介:reids-sentinel 是redis官方推荐的高可用性解决方案,当用redis作master-slave的高可用时,如果master本身宕机,redis本身或者客户端没有实现主从切换的功能,而redis-sentinel就是一个独立运行的进程,用户监控master-slave集群.自动发现master宕机,进行自动切换到slave>>>master

功能:

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

如果被标识主节点,sentinel就会与其他sentinel节点'沟通',如果其他节点也人为主节点不可达,就会选举一个sentinel节点完成自动故障转义;

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

架构:redis的一个进程,但是不存储数据,只是监控redis

#redis sentinel 故障转移流程

1.多个sentinel发现并确认master出现故障
2.选举出一个sentinel作为领导
3.选出一个slave作为master
4.通知其余slave成为新的master的slave
5.通知客户端的主从变化
6.等待原先的master恢复成为新master的slave

redis命令相关

redis-cli info   #查看redis数据库信息

redis-cli info replication  #查看redis复制授权信息

redis-cli info  sentinel   #查看redis的哨兵信息

安装和配置(一主两从的方案)

1.环境准备,主备一主两从的redis架构

redis-6379.conf 

port 6379
daemonize yes
logfile "6379.log"
dbfilename "dump-6379.rdb"
dir "/opt/redis/6379/"



redis-6380.conf 

port 6380
daemonize yes
logfile "6380.log"
dbfilename "dump-6380.rdb"
dir "/opt/redis/6380/"
slaveof  127.0.0.1  6379


redis-6381.conf 

port 6381
daemonize yes
logfile "6381.log"
dbfilename "dump-6381.rdb"
dir "/opt/redis/6381/"
slaveof  127.0.0.1  6379

2. 准备三个数据文件夹

mkdir -p /opt/redis/{6379,6380,6381}

 3.分别启动三个数据库

[root@master sbredis]# redis-server redis-6379.conf 
[root@master sbredis]# redis-server redis-6380.conf 
[root@master sbredis]# redis-server redis-6381.conf 

4.检测主从状态

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

5.准备3个redis哨兵,进行检测主从状态,准备三个哨兵配置文件

redis-66379.conf 

port 66379
dir /opt/redis/66379/
logfile "66379.log"
daemonize yes 
sentinel monitor s17ms 127.0.0.1 6379  2

sentinel down-after-milliseconds s17ms   30000

sentinel parallel-syncs s17ms 1

sentinel failover-timeout s17ms 180000


redis-66380.conf

redis-66381.conf

创建3个文件夹 mkdir -p  /opt/redis/{66379,66380,66381}

由于三个配置文件,仅仅是端口不同,通过快捷命令快速生成配置文件

sed  "s/66379/66380/g" redis-66379.conf > redis-66380.conf

sed  "s/66379/66381/g" redis-66379.conf > redis-66381.conf

6.分别启动三个哨兵

[root@master sbredis]# redis-sentinel redis-26379.conf 
[root@master sbredis]# redis-sentinel redis-26380.conf 
[root@master sbredis]# redis-sentinel redis-26381.conf 

7.检测哨兵,主从状态

redis-cli -p 26379  info sentinel
 
#看到如下信息，就和我一样了

[root@master sbredis]# redis-cli -p 26379  info  sentinel
# Sentinel
sentinel_masters:1
sentinel_tilt:0
sentinel_running_scripts:0
sentinel_scripts_queue_length:0
sentinel_simulate_failure_flags:0
master0:name=s17ms,status=ok,address=127.0.0.1:6379,slaves=2,sentinels=3

8.干掉master redis,是否自动切换

9.再次启动redis 6379  查看它是否加入主从集群

redis-cluster(redis集群)

为什么要用这个呀?

两个问题.并发问题,redis 10万/秒的并发,假如业务需要100万/秒的并发呢?;数据量太大,比如一台服务器内存正常是16G~256G,如果业务需要500G就很麻烦了,因此集群是解决这两个问题最好的办法.

虚拟槽分区

redis-cluster采用了虚拟槽分区,虚拟槽巧妙的使用了哈希空间,使用分散度良好的哈希函数把所有的数据映射到一个固定范围的整数集合,整数定义为槽(slot)

redis cluster 槽的范围 0~16383 ; 槽是集群内数据管理和迁移的基本单位,采用大范围的槽的主要目的是为了方便数据的拆分和集群的扩展,每个节点负责一定数量的槽

搭建redis-cluster

1.准备6个数据库节点,也就是6个redis实例,也就是6个配置文件

#配置文件如下:
 redis-8001.conf, redis-8002.conf, redis-8003.conf, 
 redis-8004.conf, redis-8005.conf, redis-8006.conf

#且配置内容都是一致的.仅仅是端口的不同
port 8001
daemonize yes
dir "/opt/data"
logfile "8001.log"
dbfilename "dump-8001.rdb"
cluster-enabled yes   
cluster-config-file nodes-8001.conf
cluster-require-full-coverage no

创建一个关于集群的文件夹 mkdir  clusterredis  ;在这个文件夹下  touch  redis-8000.conf 

2.创建6个redis节点,通过sed命令快速创建,仅仅是端口的区分

# sed "s/8001/8002/g" redis-8001.conf > redis-8002.conf 
# sed "s/8001/8003/g" redis-8001.conf > redis-8003.conf 
# sed "s/8001/7004/g" redis-8001.conf > redis-8004.conf 
 
# sed "s/8001/8005/g" redis-8001.conf > redis-8005.conf 
# sed "s/8001/8006/g" redis-8001.conf > redis-8006.conf 

同时创建启动所需文件 mkdir  -p /opt/data

3.分别启动6个数据库实例

# redis-server redis-8001.conf 
# redis-server redis-8002.conf 
# redis-server redis-8003.conf 
# redis-server redis-8004.conf 
# redis-server redis-8005.conf 
# redis-server redis-8006.conf 

4.开始分配redis数据库的槽位,通过ruby脚本,自动化分配槽位

5.配置ruby的解释器环境

1.下载源码
     #wget https://cache.ruby-lang.org/pub/ruby/2.3/ruby-2.3.1.tar.gz

2.释放编译文件
    #在/opt下解压缩
    # tar -zxvf ruby-2.3.1.tar.gz
    
    # 进入ruby-2.3.1目录执行如下命令
    # ./configure --prefix=/opt/ruby
    # make && make install

3.配置ruby的环境变量
    
    #进入ruby的bin目录  pwd  获取到路径 /opt/ruby/bin
    #添加环境变量   vim /etc/profile  将这个路径添加到PATH中
     #添加完毕后   执行source   /etc/profile

4.下载ruby  gem包管理工具操作redis的模块
        wget http://rubygems.org/downloads/redis-3.3.0.gem

5.通过ruby的包管理工具安装
    gem install -l redis-3.3.0.gem

6.通过ruby的脚本,自动化分配redis虚拟槽位,开启集群功能

 /opt/redis-4.0.10/src/redis-trib.rb create --replicas 1 127.0.0.1:8001 127.0.0.1:8002 127.0.0.1:8003 127.0.0.1:8004 127.0.0.1:8005 127.0.0.1:8006

7.验证集群是否开启
       #redis-cli -p 7000 cluster info
8.登录redis集群,写入数据,查看数据流向
    redis-cli -c -p 8001
    发现数据会在集群中,在节点中重定向
    #三主三从,主从数据同步,且当8001进程被kill,8004默认成为master,8001复活后成为8004的slave 

...