一、NoSQL
1、NoSql介绍
1、not only SQL，非关系型数据库，它能解决常规数据库的并发、IO与性能的瓶颈
2、解决以下问题：
① 对数据库的高并发读写需求
② 大数据的高效存储和访问需求
③ 高可扩展性和高可用性的需求
2、Nosql数据库的应用环境
1) 数据模型比较简单
2) 需要灵活性更强的IT系统
3) 对数据库的性能要求较高
4) 不需要高度数据一致性
5) 对于给定KEY，比较容易映射复杂值的环境
3、Nosql软件的分类与特点
1、key-value键值存储数据库
1) 介绍
① 键值对存储,可通过key来添加、查询、删除数据
② 用于内容缓存,适合负载并扩展大的数据集
③ 数据类型是一系列的键值对
④ 有快速查询功能,但存储数据少结构化
⑤ 对事务的支持不好,数据库故障产生时不可进行回滚
2) 常见数据库产品
redis、memcached、ttserver
3) 应用场景
存储用户信息,如会话、配置文件、参数、购物车、计数(统计粉丝关注)等
2、列存储数据库
1) 介绍
① 查询多个列
② 用于分布式的文件系统
③ 以列簇式存储,将同一列数据存在一起
④ 查找速度快,可扩展强,更容易进行分布式扩展
⑤ 功能相对局限
2) 常见数据库产品
HBase
3) 适用场景
日志(将信息写入自己的column family中)
blog平台(存储到不同的column family中,如标签、类别、文章等)
3、面向文件的数据库
1) 介绍
① 版本化的文档,半结构化的文档
② 用于WEB应用较多
③ 数据类型是一系列键值对
④ 查询性能不高,没有统一的查询语法
2) 常见数据库产品
mongoDB
3) 适用场景
日志(程序有不同的日志)
无固定的模式,存储不同的信息
分析(不改变模式,就可存储不同的度量方法,及添加新的度量)
4、图形数据库
1) 介绍
① 数据已图的方式存储
② 社交网络应用较多
③ 不容易做分布式的集群方案
2) 常见数据库产品
Graph
3) 适用场景
在关系型强的数据中,推荐引擎,社交网络,推荐系统等
4、常用的Nosql数据库介绍
1、memcached
1) 介绍
一个开源高性能的,具有分布式内存对象的缓存系统
2) 特点
① 安装布署简单
② 支持高并发、高性能
③ 通过程序或负载均衡可以实现分布式
④ 仅为内存缓存,重启服务数据丢失
2、memcacheDB
1) 介绍
新浪基于memcached开发的一个开源项目,具备了事务恢复功能
2) 特点
① 高并发读写
② 高效存储
③ 高可用数据存储
3、ttserver(tokyo tyrant/tokyocabinet)
1) 介绍
日本开发的DBM数据库,读写非常快,是BDB的几倍
2) 特点
① 支持内存缓存,可持久化存储
② 故障转移,tokyo tyrant支持主从模式,双机互为主从模式,主从库均可读写
③ 5千万条数据,级别内的访问相当快
④ 兼容memcached协议,客户端不需更改任何代码
4、mongoDB(document-oriented)
1) 介绍
一个基于分布式文件存储的数据库,由C++语言编写
2) 特点
易部署、高性能、易使用、存储数据非常方便
5、redis(key-value)
1) 介绍
用ANSIC语言编写(代码3W多行),基于内存及持久化日志型、Key-Value数据库,提供多种语言的API
2) 特点
① 支持内存缓存,相当于memcached
② 持久化,相当于memcachedb,ttserver
③ 数据类型更丰富
④ 支持集群,分布式
5、生产环境如何选择Nosql数据库
1、最常规的缓存应用,memcached最合适
2、持久化存储方案,用memcacheDB
3、2000万以内数据量的小数据,用memcached
4、大数据量,用redis
二、redis
1、redis网站
http://www.redis.cn/
http://www.redis.io/topics/introduction
2、redis特点
1、key-value键值类型存储
2、支持数据可靠存储
3、单进程单线程高性能服务器
4、恢复比较慢
5、单机qps(秒并发)可以达到10W
6、适合小数据量高速读写访问
3、redis持久化
1、介绍
redis将数据存储内存中,通过快照、日志两种方式实现持久化存储
2、持久化对比
snapshot(快照): 一次性将内存中的数据写入到磁盘,会导致数据的丢失
aof : 类似MySQL的binlog日志,记录每次更新的日志,不用于主从同步,仅能保存数据
3、配置文件对比
Snapshot(快照)
save 900 1 #900秒有1个key,则触发快照写入磁盘
save 300 10
save 60 10000
AOF(更新日志)
appendfsync always #总是记录更新内容
appendfsync everysec #每秒记录更新内容
appendfsync no #不记录更新内容
4、 redis的数据类型
String 字符串
Hash 哈希表
List 列表
Set 集合
Sorted set 有序集合
5、redis应用场景
1、计数器、好友关系、cache服务
2、微博(评论、转发、阅读、赞等),用户(粉丝、关注、收藏等)
3、用户最近访问记录、最热,点击率最高,活跃度最高的视频或帖子
6、redis的生产经验
1、要配置主从同步,在出现故障时可以切换
2、master禁用持久化,slave配置数据持久化
3、物理内存 + 虚拟内存不足,这时dump一直死着,时间久了机器会挂掉
4、当redis物理内存,使用超过内存总容量的3/5时,就开始做swap,比较危险,内存碎片大
5、当达到最大内存时,会清空带有过期时间的key,即使key未到过期时间
6、redis与db同步写的问题,先写db,后写redis
三、redis部署
1、安装redis
# wget http://download.redis.io/releases/redis-2.8.24.tar.gz
# tar zxf redis-2.8.24.tar.gz
# cd redis-2.8.24
# make
# make PREFIX=/application/redis-2.8.24 install
2、相关命令
redis-server #服务器命令
redis-cli #客户端命令,也可以用telnet连接
redis-benchmark #性能测试工具,测试读写性能
redis-check-aof #检查aof日志文件
redis-check-dump #检查本地rdb快照文件
3、启动服务
1、查看命令帮助
# redis-server -h
2、复制配置文件
# cp redis-2.8.24/redis.conf /application/redis/conf/
3、启动服务
# redis-server /application/redis/conf/redis.conf
4、关闭服务
# redis-cli shutdown
# redis-cli shutdown save
5、警告处理
1) 参数说明(vm.overcommit_memory)
0: 应用请求更多内存时,内核检查是否有足够的内存,若有,分配应用,若无,不分配,返回错误给应用
1: 内核允许分配所有的内存,不管内存状态(主要用于科学计算)
2: 内核绝不过量使用内存,即系统整个内存不能超过swap+50%的RAM值,50%在overcommit_ratio中设定
2) 永久生效
# echo "vm.overcommit_memory = 1" >> /etc/sysctl.conf
# sysctl -p
3) 临时生效
# sysctl vm.overcommit_memory=1
# echo '1' > /proc/sys/vm/overcommit_memory
4、相关命令
# redis-cli #连接本地redis
6379> set id 001 #设置key和value
6379> get id #取key的值
6379> del id #删除key
6379> exists id #验证key是否存在
6379> keys * #查看所有的key
6379> select 1 #切换到库1模式(默认有16个库,可在配置文件设置)
5、redis远程连接和非交互式操作
1、远程连接
# redis-cli -h 10.0.0.135 -p 6379
2、远程连接并执行命令
# redis-cli -h 10.0.0.135 -p 6379 set aaa 111
# redis-cli -h 10.0.0.135 -p 6379 get aaa
3、其他命令连接方式
# telnet 10.0.0.135 6379
# echo "set no004 zsq" |nc 127.0.0.1 6379
# echo "get no004 " |nc 127.0.0.1 6379
6、redis命令帮助
1、客户端命令帮助：
6379> ? #查看帮助命令用法
6379> help #查看帮助命令用法
6379> help set #查看set命令用法
2、通过help命令来查找命令
6379> help @generic #需要多次按Tab键
help + 空格 + 多次<Tab>键来切换所有命令
7、redis安全
1、设置密码
redis没有用户概念,1秒可尝试上万次的密码登陆,要设置复杂的密码,来防止暴力破解
1) 方法一:
# vim redis.conf
requirepass "123456" #设置密码
2) 方法二:
# redis-cli
6379> config set requirepass 123456
6379> config rewrite
3) 登陆方法一:
# redis-cli
6379> auth 123456
4) 登陆方法二:
# redis-cli -a 123456
2、屏蔽危险命令(命令改名)
# vim redis.conf
rename-command set "sset" #将set修改为sset
rename-command keys "" #屏蔽掉keys命令
8、安装redis客户端(php环境)
1、获取源码包
# wget https://github.com/nicolasff/phpredis/archive/master.zip
2、安装
# unzip phpredis-master.zip
# cd phpredis-master
# /application/php/bin/phpize
# ./configure --with-php-config=/application/php/bin/php-config
# make && make install
3、检查
# ls /application/php-5.6.8/lib/php/extensions/no-debug-non-zts-20131226/
memcache.so opcache.a opcache.so redis.so
4、修改设置
# vim /application/php/lib/php.ini
extension = redis.so
extension_dir = "/application/php-5.6.8/lib/php/extensions/no-debug-non-zts-20131226/"
5、重启php
# killall php-fpm
# /application/php/sbin/php-fpm
6、php操作redis
# cat redis.php
<?php
$redis = new Redis();
$redis ->connect('10.0.0.135',6379);
$redis ->auth('123456');
$redis ->set('name','zhang3');
$var = $redis ->get('name');
echo "$var
";
?>
9、安装redis客户端(Python)
1、安装
# wget https://pypi.python.org/packages/source/r/redis/redis-2.10.1.tar.gz
# tar xf redis-2.10.1.tar.gz
# cd redis-2.10.1
# python setup.py install
2、python操作redis
# python
>>> import redis #导入redis库
>>> r = redis.Redis(host='10.0.0.135',port='6379',password='123456') #连接redis(面向对象)
>>> r.set('name','benet') #写入数据
>>> r.get('name') #读取数据
>>> r.dbsize() #查看数据数
>>> r.keys() #查看所有的key
>>> exit() #退出
3、Web界面Python连接Redis
1) 编写脚本
# cat python-redis.py
#/usr/bin/python
from wsgiref.simple_server import make_server
import redis
def get_redis():
r = redis.Redis(host='10.0.0.135',port='6379',password='123456',db=0)
r.set('name','zhang3')
return r.get('name')
def hello_world_app(environ,start_response):
status = '200 OK'
headers = [('Content-type','text/plain')]
start_response(status,headers)
return get_redis()
httpd = make_server('',8000,hello_world_app)
print "Serving on port 8000..."
httpd.serve_forever()
2) 启动python脚本
# python python-redis.py
3) 访问
http://127.0.0.1:8000
10、解读redis配置文件
# vim redis.conf
include /path/to/local.conf #redis支持include功能
daemonize no #是否后台运行
pidfile /var/run/redis.pid #pid文件的位置
port 6379 #监听端口
tcp-backlog 511 #tcp监听队列
bind 10.0.0.135 #监听地址
timeout 0 #客户端超时时间
tcp-keepalive 0 #tcp的会话保持时间
loglevel notice #日志级别
logfile "" #日志记录位置,默认打印到屏幕上
syslog-facility local0 #是否启用syslog接收日志(日志集中收集)
databases 16 #库的数量(默认为0到15)
save "" #不保存快照
save 900 1 #900秒有1个key,触发快照
save 300 10 #300秒有10个key,触发快照
save 60 10000 #60秒有10000个key,触发快照
stop-writes-on-bgsave-error yes #bgsave出错是否停止写入
dbfilename dump.rdb #持久化文件名
dir ./ #持久化文件位置(默认当前路径)
rdbcompression no #是否压缩rdb文件,会消耗cpu
rdbchecksum yes #检查rdb数据
requirepass 123456 #redis的密码
rename-command CONFIG "" #屏蔽命令
rename=command get wk #命令改名
maxmemory 2G #限制redis内存
maxmemory-policy volatile-lru #内存清理的算法
appendonly no #是否启用AOF持久化
appendfilename "appendonly.aof" #AOF文件名
appendfsync everysec #每秒记录
auto-aof-rewrite-percentage 100 #自动重写(rewrite)的百分比
auto-aof-rewrite-min-size 64mb #自动重写(rewrite)aof的文件大小
lua-time-limit 5000 #lua脚本最大运行时间
hash-max-ziplist-entries 512 #hash优化参数(数量512以下,数据压缩)
hash-max-ziplist-value 64 #hash优化参数(长度小于64字节,数据压缩)
slaveof 10.0.0.135 6379 #设置主从复制
masterauth 123456 #主库密码
requirepass 123456 #本身密码
maxclients 128 #最大连接数
vm-enabled no #是否启用虚拟内存
vm-swap-file /tmp/redis.swap #虚拟内存文件路径
vm-max-memory 0 #所有大于vm-max-memory的数据,存入虚拟内存
vm-page-size 32 #虚拟内存数据页的大小
vm-pages 134217728 #虚拟内存数据页的数量
vm-max-threads 4 #访问虚拟内存文件的线程数
glueoutputbuf yes #应答客户端时,是否合并较小的包
activerehashing yes #是否激活重置哈希
四、redis数据类型
1、String (字符串)
1、介绍
string类型是二进制,很安全的,一个key对应一个value,包含任何数据,但值的长度不能超过1GB
key: 长度10到20
value: 不要超过2k
2、字符串对数字的加减
6379> set id 1 #设置key是id,值是1
6379> get id #查看key
6379> incr id #自增1
6379> incrby id 5 #自增指定数
6379> decr id #自减1
6379> decrby id 5 #自减指定数
3、其他操作
6379> getset user01 wangwu #设置新数据并返回旧数据
6379> get user01 #查看key的值
6379> mset name zhangsan age 44 #设置多个key
6379> mget name age #查看多个key的值
6379> append images .jpg #追加字符串
6379> strlen images #计算字符串长度
6379> substr images 0 6 #取0到6的值
6379> help set #查看单个命令帮助
6379> help @string #查看字符串所有命令的帮助
2、List(列表)
list是简单的字符串列表,按照插入顺序排序,可实现聊天系统和消息的队列
6379> help @list #列表帮助
6379> lpush students "zhang3" #插入元素到列表的最左边
6379> lrange students 0 1 #查看列表0到1元素的值
6379> rpush students "wang5" #将插入元素到列表的最右边
6379> llen students #查看列表元素的个数
6379> lpop students #移除最左边的元素值
6379> rpop students #移除最右边的元素值
6379> lrem students 2 "zhangsan" #删除两次指定的元素(从左向右删)
6379> lrem students 1 "zhangsan" #删除一次指定的元素
6379> lrem students 0 "zhangsan" #清空所有指定的元素
6379> linsert students before b xxxx #在元素b的前边插入新元素
6379> linsert students after b xxxx #在元素b的后边插入新元素
3、集合（Sets）类型
1、Set(无序集合)
集合通过哈希表实现的,集合内的元素具有唯一性
6379> help @set #无序集合帮助
6379> sadd users laoda #添加一个元素
6379> sadd users laoer laosan #添加两个元素
6379> smembers users #查看集合里的所有元素(集合里的元素是无序的)
6379> sismember users laoda #查看元素是否在集合中
2、zset(有序集合)
6379> help @sorted_set #有序集合帮助
6379> ZADD days 0 mon #days:有序集合名,0:序号,mon:值
6379> zrange days 0 6 #查看集合0到6元素的值(正序)
6379> zrevrange days 0 -1 #查看集合所有元素的值(倒序)
6379> zscore days mon #查看集合里值的排序
6379> zrangebyscore days -inf 8 #查看负无穷到5之间元素的值(区间查询)
6379> zremrangebyscore days 1 7 #删除1到7之间的元素(删除之间的元素)
4、Hash类型
哈希可存储多个属性的数据(如user,name passwd)
6379> hset k1 name zhang3 age 23 #k1:哈希名,name:属性1,age:属性1
6379> hvals k1 #查看所有属性
6379> hgetall k1 #查看所有属性和值
五、redis多实例
1、创建多实例目录和配置文件
1、创建redis多实例目录
# mkdir -p /data/redis/638{0..1}/{conf,logs,pid}
2、创建redis多实例配置文件
# cp redis.conf /data/6380/conf/redis_6380.conf
# cp redis.conf /data/6381/conf/redis_6381.conf
# vim redis_6380.conf
bind 10.0.0.135
port 6380
daemonize yes
dir /data/redis/6380/
pidfile /data/6380/redis_6380.pid
logfile /data/6380/logs/redis_6380.log
dbfilename redis_6380.rdb
appendonly yes
appendfilename redis.aof
# sed -i 's#6380#6381#g' /data/6381/conf/redis_6381.conf
2、启动redis多实例
1、启动
# redis-server /data/redis/6380/conf/redis_6380.conf
# redis-server /data/redis/6381/conf/redis_6381.conf
2、查看端口和进程
# netstat -antup | grep redis
# ps -ef | grep redis
六、 Redis主从同步
1、Redis主从同步特点
1、一个master可以拥有多个slave
2、多个slave可以连接同一个master,还可以连接到其他slave
3、主从复制不会阻塞master,在同步数据时,master可以继续处理客户端的请求
4、提高系统的伸缩性
2、Redis主从同步的过程
1、Slave连接到Master服务器
2、Slave发送SYNC命令
3、Master备份数据到rdb文件
4、Master把rdb文件传输给Slave
5、Slave把rdb文件导入到数据库中
3、Redis的主从同步的应用
1、一个master可有多个slave,一个slave还可以有多个slave
2、主从同步不会阻塞master,但是会阻塞slave(初次同步数据,会阻塞客户端的请求)
3、主从同步提高系统的伸缩,用多个slave处理客户端的读请求
4）master不做持久化,在slave上做,可提高集群的性能,也可在slave上做数据的备份
5）对于老版本的redis,每次重连都会重新发送所有数据
4、配置主从同步
1、方法1(临时生效)
# redis-cli slaveof 10.0.0.135 6380 #启动主从同步
# redis-cli slaveof no one #停止主从同步
2、方法2(永久生效)
# vim redis_6381.conf
slaveof 10.0.0.135 6380 #主库的IP和端口
masterauth 123456 #主库的密码
5、同步过程
* Connecting to MASTER 192.168.0.135:6379 #连接master
* MASTER <-> SLAVE sync started #开始发送sync
* Non blocking connect for SYNC fired the event. #这是一个不阻塞事件
* Master replied to PING, replication can continue... #master应答了ping,同步开始
* Partial resynchronization not possible (no cached master) #部分重新同步不可能(master无缓存内容)
* Full resync from master: #从master同步全部数据
* MASTER <-> SLAVE sync: receiving 49 bytes from master #从master接收到49字节数据
* MASTER <-> SLAVE sync: Flushing old data #刷新旧数据
* MASTER <-> SLAVE sync: Loading DB in memory #数据放到内存
* MASTER <-> SLAVE sync: Finished with success #同步完成
* Background append only file rewriting started by pid 3620 #AOF重写
* Background AOF rewrite terminated with success #AOF重写成功
* Background AOF rewrite finished successfully #AOF重写完毕
6、主从相关参数
1、主从同步测试
# redis-cli -a 123456 -p 6381 monitor #监听主服务写入操作
# redis-cli -a 123456 -p 6380 get name #查看key
# redis-cli -a 123456 -p 6380 set name tom #设置一个key和value
2、主从同步相关参数
slave-serve-stale-data yes #yes:从不能连接主,从可正常提供服务,数据是旧的,no:不提供服务,返回错误信息
slave-read-only yes #设置从库只读模式
repl-ping-slave-period 10 #每10秒发送ping到master
repl-backlog-size 1mb #backlog大小(主通过backlog实现从的增量同步)
repl-backlog-ttl 3600 #主从断开时,backlog的生存周期
slave-priority 100 #slave的优先级
3、查看redis各项参数的方法
6379> info #查看所有的信息
6379> info cpu #查看CPU的信息
6379> info clients #查看客户端信息
6379> info replication #查看同步信息
role:master #角色是主
connected_slaves:1 #连接从的数量
slave0:ip="",port="",state=online,offset=11972,lag=1 #从库ip,端口,状态,偏移量等
七、redis的高级特性
1、redis的订阅功能
1、介绍
pub(发布)/sub(订阅)是一种消息通信模式,主要目的解耦发布者和订阅者之间的耦合
redis可将数据推到消息队列中,其它人可通过队列获取消息
2、开启的订阅功能
6379> subscribe first #开启并订阅频道(一个窗口)
6379> subscribe first second #可订阅多个频道
3、对频道推送
6379> publish first 'welcome' #向频道推送
6379> (integer) 2 #推送成功的人数(只要推送端推送,订阅端就能看到)
6379> help @pubsub #更多获取帮助
2、redis数据过期设置及过期机制
1、过期机制
1) 定时删除
设置key的过期时间的同时,创建一个定时器,到期时触发,对key删除
2) 惰性删除
key过期不删除,每次访问时检查是否过期,若过期,则删除key,并返回空(null)
3) 定期删除
每隔一段时间,检查有过期时间的key,删除已过期的key
2、过期设置
6379> expire name 5 #设置key5秒后过期
6379> TTL name #查看key过期时间(-1:永不过期,-2:已过期)
6379> get name #过期后的key,无法获取value的
6379> help @generic
3、事务性
1、组合型的命令
redis支持简单的组合型的命令,例如以nx结尾的命令,key不存在时,为key设置指定的值
6379> exists name #查询key是否存在
6379> setnx name tom #当key不存在时,设置key的值
6379> setnx name zhang3 #当key存在时,不执行任何操作
6379> get name #没有被覆盖
2、事务
6379> set name tom #设置一个key
6379> get name #查看key的值
6379> multi #开始一个事务
6379> set name a #当事务中有错误时,将都不执行
6379> set name b
6379> exec #提交事务(discard:取消事务)
4、redis持久化
1、快照(Snapshotting)
1) 介绍
将内存中数据,以快照的方式写入到文件中,redis宕机会丢失最后一次快照的数据
2) 配置
方法一
# vim redis.conf
dir /data/redis/ #rdb存储的路径
dbfilename dump.rdb #rdb文件名
save 900 1 #900秒内1个key被修改,触发快照
save 300 10 #300秒内10个key被修改,触发快照
save 60 10000 60秒内10000个key被修改,触发快照
rdbcompression no #关闭rdb压缩,影响cpu
save "" #关闭rdb
方法二
6379> redis-cli config set save "180 1 120 10 60 10000" #开启rdb
6379> redis-cli config rewrite #配置保存到文件
6379> redis-cli config set save "" #关闭rdb
3) 快照原理
① redis调用fork,产生一个子进程
② 父进程处理client请求,子进程将内存内容写入到临时文件,由于Linux的写时复制机制,子进程的数据是fork时的一个快照
③ 当子进程将快照写入临时文件后,把临时文件替换快照文件,然后子进程退出
4) 命令快照
save: 主线程保存快照,会阻塞所有client请求(不推荐)
bgsave: 开启一个子进程保存快照,不会阻塞客户端请求(推荐)
5) 其他
每次快照都是将内存数据完整写入到磁盘,如果数据量大,写操作多,会引起大量的磁盘io,严重影响性能
redis关闭时,会自动后台保存并退出,启动时,会读取RDB文件,若找不到RDB文件,则认为数据丢失
2、aof(日志方式)
1) 介绍
redis将收到的写操作,通过write函数追加到文件中,类似MySQL的binlog日志方式
2) 配置
# vim redis.conf
appendonly yes #启用aof
3) aof文件更新策略
appendfsync always #收到写命令就立即写入磁盘,最慢,但数据不会丢失
appendfsync everysec #默认方式,每秒写入磁盘一次,会丢失前1秒的数据
appendfsync no #完全依赖os,性能最好,数据会丢失
4) aof文件的自动重写
auto-aof-rewrite-percentage 100 #当aof文件增长比例100%时,触发自动重写
auto-aof-rewrite-min-size 64mb #当aof文件大小到64m,触发自动重写
6379> bgrewriteaof #手动触发自动重写
5) aof保存过程
① redis调用fork,产生一个子进程
② 子进程会根据内存中的快照,往临时文件中写人数据变化的命令
③ 父进程处理client请求,并把收到的写操作缓存
④ 当子进程把快照内容写完后,发信号通知父进程,父进程把缓存的写命令,写入到临时文件中
⑤ 父进程用临时文件,替换老的aof文件,并重命名,后面收到的写命令,往新的aof文件中追加
备注: 重写aof文件,并没有读取旧的aof文件,而是重写一个新的aof文件,当redis启动会加载aof文件,用命令重建整个数据库
八、redis的优化
1、常用命令
6379> flushdb #清空当前库的数据
6379> flushall #清空所有库的数据
6379> config get * #查看当前配置信息
6379> config set appendonly yes #在线修改
# redis-benchmark -h 127.0.0.1 -p 6379 -c 100 -n 10000 #100个并发,一万次请求
2、系统参数优化
1) 系统文件描述符
# echo "* - nofile 10240" >> /etc/security/limits.conf
# bash && ulimit -n
2) TCP连接数
# echo "net.core.somaxconn = 10240" >> /etc/sysctl.conf
# sysctl -p
3) 系统内存分配策略
# echo "vm.overcommit_memory = 1" >> /etc/sysctl.conf
# sysctl -p
4) 关闭系统大页内存
# echo never > /sys/kernel/mm/transparent_hugepage/enabled
# echo never > /sys/kernel/mm/transparent_hugepage/defrag
3、内存清理算法
volatile-lru #LRU算法删除过期的key
volatile-random #随机删除过期的key
volatile-ttl #删除即将过期的key
allkeys-lru #LRU算法删除所有key
allkeys-random #随机删除所有key
noeviction #不删除key,只返回错误
6379> config get maxmemory-policy #查看内存清理算法
6379> config get maxmemory-policy volatile-lru #设置内存清理算法
4、内存优化
hash-max-zipmap-entries 64 #hash的最大元素数,当超过时,采用特殊hash算法
hash-max-zipmap-value 512 #hash的最大元素值,当超过时,采用特殊hash算法
list-max-ziplist-value 64 #列表的最大元素值,当超过时,采用压缩列表
list-max-ziplist-entries 512 #列表的最大元素数,当超过时,采用压缩列表
set-max-intset-entries 512 #限制集合中member个数,超出则不采取intset存储
activerehashing yes #是否激活重置哈希
5、redis优化总结
① 根据业务需要,选择合适的数据类型,并为不同的应用场景,设置相应的紧凑存储参数
② 当业务场景不需要数据持久化时,关闭持久化,可获得最佳的性能和最大的内存使用量
③ 若使用持久化,根据是否容忍丢失部分数据,选择持久化方式,不要用虚拟内存vm及disk store方式,每秒实时写入AOF文件
④ 尽量不要让redis的内存,超过总内存的60%
⑤ 设置参数maxmemory,限制redis不会过多,使用物理内存而导致swap,设置参数vm-enabled no(不用虚拟内存)
⑥ 大数据量尽量按业务,用多个redis instance把数据分散开
6、批量插入数据
for i in `seq -w 50`;do redis-cli set name_$i value_$i;done
九、redis的状态信息
1、服务器的信息
# Server
redis_version:4.0.10 #redis服务器版本
redis_mode:standalone #运行模式(单机或集群)
multiplexing_api:epoll #使用的事件处理模型
uptime_in_days:0 #服务器启动总时间,单位是天
hz:10 #redis内部调度(关闭timeout客户端,删除过期key)
lru_clock:8197344 #自增时间,用于LRU管理
2、客户端信息
# Clients
connected_clients:1 #当前客户端连接数(不包括slave的连接)
blocked_clients:0 #被阻塞的客户端数
3、内存信息
# Memory
used_memory:2995728 #已用的内存,单位为字节(byte)
used_memory_human:2.86M #易读方式显示
used_memory_rss:4636672 #系统给redis分配的内存(和top、ps显示的一致)
used_memory_rss_human:4.42M #易读方式显示
used_memory_peak:15517016 #内存使用的峰值大小
used_memory_peak_human:14.80M #易读方式显示
used_memory_peak_perc:19.31% #峰值内存超出分配内存(used_memory)的百分比
used_memory_startup:786608 #Redis启动时的初始内存
total_system_memory:2229866496 #系统内存总量
total_system_memory_human:2.08G #易读方式显示
used_memory_lua:37888 #lua引擎使用的内存
used_memory_lua_human:37.00K #易读方式显示
maxmemory:0 #最大内存(0不限制)
maxmemory_human:0B #易读方式显示
mem_fragmentation_ratio:1.55 #内存碎片率(used_memory_rss和used_memory的比率,小于1:使用swap,大于1:碎片多,增删操作增加碎片)
mem_allocator:jemalloc-4.0.3 #内存分配器
4、持久化信息
# Persistence
loading:0 #是否正在加载持久化文件
rdb_changes_since_last_save:0 #自上次rdb后,数据的改动
rdb_bgsave_in_progress:0 #bgsave是否操作
rdb_last_save_time:1534918159 #上次bgsave的时间戳
rdb_last_bgsave_status:ok #上次bgsave的状态
rdb_last_bgsave_time_sec:0 #上次bgsave的使用的时间
rdb_current_bgsave_time_sec:-1 #当前bgsave已耗费的时间(如果有)
rdb_last_cow_size:438272 #上次rbd写时复制分配的字节大小
aof_enabled:1 #是否开启AOF
aof_rewrite_in_progress:0 #AOF是否正在自动重写(rewrite)
aof_rewrite_scheduled:0 #是否要在rdb的bgsave结束后执行rewrite
aof_last_rewrite_time_sec:1 #上次rewrite使用的时间(单位s)
aof_current_rewrite_time_sec:-1 #当前rewrite已耗费的时间(如果有)
aof_last_bgrewrite_status:ok #上次bgrewrite的状态
aof_last_write_status:ok #上次AOF文件写入状态
aof_last_cow_size:581632 #上次重写写时复制分配的字节大小
aof_current_size:2634673 #AOF当前大小
aof_base_size:2473591 #AOF上次启动或rewrite的大小
aof_pending_rewrite:0 #同上面的aof_rewrite_scheduled
aof_buffer_length:0 #AOF buffer的大小
aof_rewrite_buffer_length:0 #AOF rewrite buffer的大小
aof_pending_bio_fsync:0 #后台IO队列中等待fsync执行的个数
aof_delayed_fsync:0 #被延迟fsync调用数量
5、统计信息
# Stats
total_connections_received:220209 #连接过的客户端总数
total_commands_processed:447805 #执行过的命令总数
instantaneous_ops_per_sec:0 #每秒处理命令数
total_net_input_bytes:13682780 #输入网络流量总数
total_net_output_bytes:10737650 #输出网络流量总数
instantaneous_input_kbps:0.02 #网络读取速率
instantaneous_output_kbps:0.00 #网络写入速率
rejected_connections:0 #拒绝的连接个数(已达到maxclients限制)
sync_full:1 #主从完全同步成功次数
sync_partial_ok:0 #主从部分同步成功次数
sync_partial_err:1 #主从部分同步失败次数
expired_keys:0 #过期key的数量
evicted_keys:0 #剔除(超过maxmemory)的key的数量
keyspace_hits:0 #命中key次数
keyspace_misses:0 #没命中key次数
pubsub_channels:0 #当前使用中的频道数量
pubsub_patterns:0 #当前使用中的模式数量
latest_fork_usec:401 #上次fork消耗的时间
6、主从信息
# Replication
role:master #角色(主从)
connected_slaves:1 #连接的从库数量
slave0:ip="",port="",state=online,offset=123,lag=0 #从库信息
master_replid:2757c33a #复制ID
master_replid2:0000000 #第二个复制ID(用于failover的PSYNC)
master_repl_offset:7672755 #主从同步偏移量
repl_backlog_active:1 #复制缓冲区的状态
repl_backlog_size:1048576 #复制缓冲区的大小
repl_backlog_first_byte_offset:6624180 #复制缓冲区的主偏移量
repl_backlog_histlen:1048576 #复制缓冲区数据的大小
7、cpu信息
# CPU
used_cpu_sys:23.63 #主进程内核态消耗cpu的时间
used_cpu_user:13.16 #主进程用户态消耗cpu的时间
used_cpu_sys_children:0.31 #子进程内核态消耗cpu的时间
used_cpu_user_children:0.14 #子进程用户态消耗cpu的时间
8、集群信息
# Cluster
cluster_enabled:0 #集群未开启
9、数据库的键值信息
# Keyspace
db0:keys=1,expires=0,avg_ttl=0 #key总数,带有过期时间的key的总数,平均存活时间
十、redis的高可用(哨兵+vip)
1、环境
redis-server sentinel(哨兵)
主节点 192.168.1.11:8000 192.168.1.11:7000
从节点 192.168.1.12:8000 192.168.1.12:7000
从节点 192.168.1.13:8000 192.168.1.13:7000
2、配置主从复制(sentinel基于主从)
1、创建master配置文件(主节点)
# vim redis.conf
port 8000
daemonize yes
bind 0.0.0.0
pidfile /var/run/redis-8000.pid
logfile /var/log/redis/redis-8000.log
requirepass 123456
2、创建slave配置文件(2个从节点)
# vim redis.conf
port 8000
daemonize yes
bind 0.0.0.0
pidfile /var/run/redis-8000.pid
logfile /var/log/redis/redis-8000.log
slaveof 192.168.1.11 8000
masterauth 123456
3、启动redis(所有节点)
# redis-server redis.conf
3、安装部署redis-sentinel(所有节点)
1、创建sentinel配置文件
# vim sentinel.conf
port 7000
sentinel monitor mymaster 192.168.1.11 8000 2 #监控,别名,主库ip和端口,投票数2
sentinel down-after-milliseconds mymaster 5000 #主库宕机5秒,切库
sentinel parallel-syncs mymaster 1 #切库后,向主库同步数据的个数,1:轮询,2:并发
sentinel failover-timeout mymaster 15000 #故障转移的超时时间
sentinel auth-pass mymaster 123456 #主库密码
2、启动sentinel
# redis-sentinel sentinel.conf
3、查看sentinel信息
# redis-cli -h 192.168.1.11 -p 7000 info sentinel
4、部署redis-sentinel的VIP
1、修改配置文件(所有节点)
# vim sentinel.conf
port 7000
sentinel monitor mymaster 192.168.1.11 8000 2
sentinel down-after-milliseconds mymaster 5000
sentinel parallel-syncs mymaster 1
sentinel failover-timeout mymaster 15000
sentinel auth-pass mymaster 123456
sentinel client-reconfig-script mymaster /data/redis/redis_vip.sh
2、编写vip脚本(所有节点)
sentinel在failover的时会执行client-reconfig-script脚本,
并传递6个参数(<master-name>,<role>,<state>,<from-ip>,<from-port>,<to-ip>,<to-port>)
# vim /data/redis/redis_vip.sh
#!/bin/bash
MASTER_IP=$6 #传第六个参数(新master的IP==<to-ip>)
LOCAL_IP="192.168.1.12" #本地IP
VIP="192.168.1.20" #VIP
NETMASK="24"
INTERFACE="eth0"
if [[ "${MASTER_IP}" == "${LOCAL_IP}" ]];then
/usr/sbin/ip addr add ${VIP}/${NETMASK} dev ${INTERFACE}
/usr/sbin/arping -q -c 3 -A ${VIP} -I ${INTERFACE}
exit 0
else
/usr/sbin/ip addr del ${VIP}/${NETMASK} dev ${INTERFACE}
exit 0
fi
exit 1
# chmod +x /data/redis/redis_vip.sh
3、重启服务(所有节点)
# redis-cli -h 192.168.1.11 -p 7000 shutdown
# redis-sentinel sentinel.conf
# ip addr add 192.168.1.20/24 dev eth0 #第一次时手动给master添加VIP
# arping -q -c 3 -A 192.168.1.20 -I eth0 #让ip地址即刻生效
十一、Redis Cluster集群
1、介绍
Redis集群使用数据分片来实现,一个集群有16384个哈希槽,支持主从自动切换,无中心化,不支持多库,只有一个db0
2、环境(3节点)
主节点 db01: 10.0.0.11:7000 db02: 10.0.0.12:7000 db03: 10.0.0.13:7000
从节点 db02: 10.0.0.12:8000 db03: 10.0.0.13:8000 db01: 10.0.0.11:8000
3、redis部署和调优
1、安装redis
# yum -y install wget gcc gcc-c++ make tar openssl openssl-devel cmake
# tar xf redis-4.0.10.tar.gz -C /usr/src/
# cd /usr/src/redis-4.0.10/
# make
# make MALLOC=jemalloc
# make PREFIX=/usr/local/redis install
2、系统调优
# echo "* - nofile 10240" >> /etc/security/limits.conf
# echo "net.core.somaxconn = 10240" >> /etc/sysctl.conf
# echo "vm.overcommit_memory = 1" >> /etc/sysctl.conf
# sysctl -p
# echo never > /sys/kernel/mm/transparent_hugepage/enabled
# echo never > /sys/kernel/mm/transparent_hugepage/defrag
# echo 'echo never > /sys/kernel/mm/transparent_hugepage/enabled' >> /etc/rc.local
# echo 'echo never > /sys/kernel/mm/transparent_hugepage/defrag' >> /etc/rc.local
4、安装部署redis集群
1、创建目录(所有节点)
# mkdir -p /data/redis-cluster/{7000,8000}
2、创建配置文件(所有节点)
① master配置文件
# vim /data/redis-cluster/7000/redis_7000.conf
bind 0.0.0.0
protected-mode yes
port 7000
tcp-backlog 1024
timeout 0
tcp-keepalive 0
daemonize yes
supervised no
pidfile /data/redis-cluster/7000/redis_7000.pid
loglevel notice
logfile /data/redis-cluster/7000/redis_7000.log
databases 16
always-show-logo yes
save 900 1
save 300 10
save 60 10000
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename redis_7000.rdb
dir /data/redis-cluster/7000/
slave-serve-stale-data yes
slave-read-only yes
repl-diskless-sync no
repl-diskless-sync-delay 5
repl-disable-tcp-nodelay no
slave-priority 100
lazyfree-lazy-eviction no
lazyfree-lazy-expire no
lazyfree-lazy-server-del no
slave-lazy-flush no
appendonly no
appendfilename "appendonly.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 no
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
activerehashing yes
client-output-buffer-limit normal 0 0 0
client-output-buffer-limit slave 256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60
hz 10
aof-rewrite-incremental-fsync yes
cluster-enabled yes #开启集群模式
cluster-config-file nodes_7000.conf #集群node配置文件(动态更新)
cluster-node-timeout 5000 #集群的超时时间
② slave配置文件
# cp redis_7000.conf /data/redis-cluster/8000/redis_8000.conf
# sed -i 's#7000#8000#g' redis_8000.conf
3、启动集群(所有节点)
# redis-server /data/redis-cluster/7000/redis_7000.conf
# redis-server /data/redis-cluster/8000/redis_8000.conf
5、使用工具自动部署集群
1、安装ruby环境(编译安装高版本ruby,版本大于2.2)
# wget --no-check-certificate 'https://cache.ruby-lang.org/pub/ruby/2.2/ruby-2.2.7.tar.gz'
# tar xf ruby-2.2.7.tar.gz -C /usr/src/
# cd /usr/src/ruby-2.2.7/
# ./configure && make && make install
# ruby --version
2、在线安装ruby的redis扩展
# gem install redis #版本要和redis差不多,大版本号一直
# gem install redis -v 3.3.5 #可指定版本安装
3、使用工具部署集群(master上操作)
# redis-trib.rb create 10.0.0.11:7000 10.0.0.12:7000 10.0.0.13:7000
4、查看集群的信息
# redis-cli -p 7000 cluster nodes
5、操作集群
# redis-cli -c -p 7000 set name zhang3
# redis-cli -c -p 7000 get name
6、集群的重建(所有节点)
1、删除cluster集群配置文件
# rm -rf /data/redis-cluster/7000/nodes_7000.conf
2、关闭集群
# redis-cli -p 7000 shutdown
3、启动集群
# redis-server /data/redis-cluster/7000/redis_7000.conf
4、重新创建redis-cluster集群
# redis-trib.rb create 10.0.0.11:7000 10.0.0.12:7000 10.0.0.13:7000
5、查看进程
# ps -ef | grep cluster | grep -v grep
7、集群添加从库
# redis-trib.rb add-node --slave 10.0.0.12:8000 10.0.0.11:7000 #添加从8000,主7000
# redis-trib.rb add-node --slave 10.0.0.13:8000 10.0.0.12:7000
# redis-trib.rb add-node --slave 10.0.0.11:8000 10.0.0.13:7000
# redis-cli -p 7000 cluster nodes #查看集群所有节点的信息
8、其他
1、集群的主从自动切换
# redis-cli -p 7000 shutdown #手动宕掉主
# redis-cli -p 8000 cluster nodes #查看状态(从库变新主库)
# redis-server /data/redis-cluster/7000/redis_7000.conf #启动主
# redis-cli -p 8000 cluster nodes #查看状态(主库变新从库)
# redis-cli -p 7000 cluster failover #手动切换主从(主从角色切换)
# redis-cli -p 8000 cluster nodes #查看状态(新从库变旧主库)
2、Python操作集群
# yum install python2-pip
# pip install redis-py-cluster
# vim redis_cluster.py
# -*- coding:utf-8 -*-
from rediscluster import StrictRedisCluster
redis_nodes = [
{'host':'10.0.0.11','port':7000},
{'host':'10.0.0.12','port':7000},
{'host':'10.0.0.13','port':7000},
{'host':'10.0.0.11','port':8000},
{'host':'10.0.0.12','port':8000},
{'host':'10.0.0.13','port':8000}
]
redis_conn = StrictRedisCluster(startup_nodes=redis_nodes)
redis_conn.set('key_test','values_test')
print(redis_conn.get('key_test'))
# python redis_cluster.py #执行Python脚本
# redis-cli -c -p 7000 get key_test #查看key
备注: 若其中一个节点挂了,不影响使用
3、分析Redis的所有key和key的大小
# pip install rdbtools #pip安装rdbtools分析工具
# rdb -c memory redis_7000.rdb > /tmp/rdb.csv
# cat /tmp/rdb.csv | head