对主从 Redis 进行 QPS 压测

2024-06-15 07:48
文章标签 进行 redis 压测 主从 qps

本文主要是介绍对主从 Redis 进行 QPS 压测,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

1、对redis读写分离架构进行压测,单实例写QPS+单实例读QPS

 
  1. redis-3.2.8/src

  2.  
  3. ./redis-benchmark -h 192.168.31.187

  4.  
  5. -c <clients> Number of parallel connections (default 50) // 并发

  6. -n <requests> Total number of requests (default 100000) // 总数

  7. -d <size> Data size of SET/GET value in bytes (default 2) // 大小

  8.  
  9. 根据你自己的高峰期的访问量,在高峰期,瞬时最大用户量会达到10万+,-c 100000,-n 10000000,-d 50

  10.  
  11. 各种基准测试,直接出来

  12.  
  13. 1核1G,虚拟机

  14.  
  15. ====== PING_INLINE ======

  16. 100000 requests completed in 1.28 seconds

  17. 50 parallel clients

  18. 3 bytes payload

  19. keep alive: 1

  20.  
  21. 99.78% <= 1 milliseconds

  22. 99.93% <= 2 milliseconds

  23. 99.97% <= 3 milliseconds

  24. 100.00% <= 3 milliseconds

  25. 78308.54 requests per second

  26.  
  27. ====== PING_BULK ======

  28. 100000 requests completed in 1.30 seconds

  29. 50 parallel clients

  30. 3 bytes payload

  31. keep alive: 1

  32.  
  33. 99.87% <= 1 milliseconds

  34. 100.00% <= 1 milliseconds

  35. 76804.91 requests per second

  36.  
  37. ====== SET ======

  38. 100000 requests completed in 2.50 seconds

  39. 50 parallel clients

  40. 3 bytes payload

  41. keep alive: 1

  42.  
  43. 5.95% <= 1 milliseconds

  44. 99.63% <= 2 milliseconds

  45. 99.93% <= 3 milliseconds

  46. 99.99% <= 4 milliseconds

  47. 100.00% <= 4 milliseconds

  48. 40032.03 requests per second

  49.  
  50. ====== GET ======

  51. 100000 requests completed in 1.30 seconds

  52. 50 parallel clients

  53. 3 bytes payload

  54. keep alive: 1

  55.  
  56. 99.73% <= 1 milliseconds

  57. 100.00% <= 2 milliseconds

  58. 100.00% <= 2 milliseconds

  59. 76628.35 requests per second

  60.  
  61. ====== INCR ======

  62. 100000 requests completed in 1.90 seconds

  63. 50 parallel clients

  64. 3 bytes payload

  65. keep alive: 1

  66.  
  67. 80.92% <= 1 milliseconds

  68. 99.81% <= 2 milliseconds

  69. 99.95% <= 3 milliseconds

  70. 99.96% <= 4 milliseconds

  71. 99.97% <= 5 milliseconds

  72. 100.00% <= 6 milliseconds

  73. 52548.61 requests per second

  74.  
  75. ====== LPUSH ======

  76. 100000 requests completed in 2.58 seconds

  77. 50 parallel clients

  78. 3 bytes payload

  79. keep alive: 1

  80.  
  81. 3.76% <= 1 milliseconds

  82. 99.61% <= 2 milliseconds

  83. 99.93% <= 3 milliseconds

  84. 100.00% <= 3 milliseconds

  85. 38684.72 requests per second

  86.  
  87. ====== RPUSH ======

  88. 100000 requests completed in 2.47 seconds

  89. 50 parallel clients

  90. 3 bytes payload

  91. keep alive: 1

  92.  
  93. 6.87% <= 1 milliseconds

  94. 99.69% <= 2 milliseconds

  95. 99.87% <= 3 milliseconds

  96. 99.99% <= 4 milliseconds

  97. 100.00% <= 4 milliseconds

  98. 40469.45 requests per second

  99.  
  100. ====== LPOP ======

  101. 100000 requests completed in 2.26 seconds

  102. 50 parallel clients

  103. 3 bytes payload

  104. keep alive: 1

  105.  
  106. 28.39% <= 1 milliseconds

  107. 99.83% <= 2 milliseconds

  108. 100.00% <= 2 milliseconds

  109. 44306.60 requests per second

  110.  
  111. ====== RPOP ======

  112. 100000 requests completed in 2.18 seconds

  113. 50 parallel clients

  114. 3 bytes payload

  115. keep alive: 1

  116.  
  117. 36.08% <= 1 milliseconds

  118. 99.75% <= 2 milliseconds

  119. 100.00% <= 2 milliseconds

  120. 45871.56 requests per second

  121.  
  122. ====== SADD ======

  123. 100000 requests completed in 1.23 seconds

  124. 50 parallel clients

  125. 3 bytes payload

  126. keep alive: 1

  127.  
  128. 99.94% <= 1 milliseconds

  129. 100.00% <= 2 milliseconds

  130. 100.00% <= 2 milliseconds

  131. 81168.83 requests per second

  132.  
  133. ====== SPOP ======

  134. 100000 requests completed in 1.28 seconds

  135. 50 parallel clients

  136. 3 bytes payload

  137. keep alive: 1

  138.  
  139. 99.80% <= 1 milliseconds

  140. 99.96% <= 2 milliseconds

  141. 99.96% <= 3 milliseconds

  142. 99.97% <= 5 milliseconds

  143. 100.00% <= 5 milliseconds

  144. 78369.91 requests per second

  145.  
  146. ====== LPUSH (needed to benchmark LRANGE) ======

  147. 100000 requests completed in 2.47 seconds

  148. 50 parallel clients

  149. 3 bytes payload

  150. keep alive: 1

  151.  
  152. 15.29% <= 1 milliseconds

  153. 99.64% <= 2 milliseconds

  154. 99.94% <= 3 milliseconds

  155. 100.00% <= 3 milliseconds

  156. 40420.37 requests per second

  157.  
  158. ====== LRANGE_100 (first 100 elements) ======

  159. 100000 requests completed in 3.69 seconds

  160. 50 parallel clients

  161. 3 bytes payload

  162. keep alive: 1

  163.  
  164. 30.86% <= 1 milliseconds

  165. 96.99% <= 2 milliseconds

  166. 99.94% <= 3 milliseconds

  167. 99.99% <= 4 milliseconds

  168. 100.00% <= 4 milliseconds

  169. 27085.59 requests per second

  170.  
  171. ====== LRANGE_300 (first 300 elements) ======

  172. 100000 requests completed in 10.22 seconds

  173. 50 parallel clients

  174. 3 bytes payload

  175. keep alive: 1

  176.  
  177. 0.03% <= 1 milliseconds

  178. 5.90% <= 2 milliseconds

  179. 90.68% <= 3 milliseconds

  180. 95.46% <= 4 milliseconds

  181. 97.67% <= 5 milliseconds

  182. 99.12% <= 6 milliseconds

  183. 99.98% <= 7 milliseconds

  184. 100.00% <= 7 milliseconds

  185. 9784.74 requests per second

  186.  
  187. ====== LRANGE_500 (first 450 elements) ======

  188. 100000 requests completed in 14.71 seconds

  189. 50 parallel clients

  190. 3 bytes payload

  191. keep alive: 1

  192.  
  193. 0.00% <= 1 milliseconds

  194. 0.07% <= 2 milliseconds

  195. 1.59% <= 3 milliseconds

  196. 89.26% <= 4 milliseconds

  197. 97.90% <= 5 milliseconds

  198. 99.24% <= 6 milliseconds

  199. 99.73% <= 7 milliseconds

  200. 99.89% <= 8 milliseconds

  201. 99.96% <= 9 milliseconds

  202. 99.99% <= 10 milliseconds

  203. 100.00% <= 10 milliseconds

  204. 6799.48 requests per second

  205.  
  206. ====== LRANGE_600 (first 600 elements) ======

  207. 100000 requests completed in 18.56 seconds

  208. 50 parallel clients

  209. 3 bytes payload

  210. keep alive: 1

  211.  
  212. 0.00% <= 2 milliseconds

  213. 0.23% <= 3 milliseconds

  214. 1.75% <= 4 milliseconds

  215. 91.17% <= 5 milliseconds

  216. 98.16% <= 6 milliseconds

  217. 99.04% <= 7 milliseconds

  218. 99.83% <= 8 milliseconds

  219. 99.95% <= 9 milliseconds

  220. 99.98% <= 10 milliseconds

  221. 100.00% <= 10 milliseconds

  222. 5387.35 requests per second

  223.  
  224. ====== MSET (10 keys) ======

  225. 100000 requests completed in 4.02 seconds

  226. 50 parallel clients

  227. 3 bytes payload

  228. keep alive: 1

  229.  
  230. 0.01% <= 1 milliseconds

  231. 53.22% <= 2 milliseconds

  232. 99.12% <= 3 milliseconds

  233. 99.55% <= 4 milliseconds

  234. 99.70% <= 5 milliseconds

  235. 99.90% <= 6 milliseconds

  236. 99.95% <= 7 milliseconds

  237. 100.00% <= 8 milliseconds

  238. 24869.44 requests per second

 
  1. 我们这个读写分离这一块的第一讲

  2.  
  3. 大部分情况下来说,看你的服务器的机器性能和配置,机器越牛逼,配置越高

  4.  
  5. 单机上十几万,单机上二十万

  6.  
  7. 很多公司里,给一些低配置的服务器,操作复杂度

  8.  
  9. 大公司里,都是公司会提供统一的云平台,比如京东、腾讯、BAT、其他的一些、小米、美团

  10.  
  11. 虚拟机,低配

  12.  
  13. 搭建一些集群,专门为某个项目,搭建的专用集群,4核4G内存,比较复杂的操作,数据比较大

  14.  
  15. 几万,单机做到,差不多了

  16.  
  17. redis提供的高并发,至少到上万,没问题

  18.  
  19. 几万~十几万/二十万不等

  20.  
  21. QPS,自己不同公司,不同服务器,自己去测试,跟生产环境还有区别

  22.  
  23. 生产环境,大量的网络请求的调用,网络本身就有开销,你的redis的吞吐量就不一定那么高了

  24.  
  25. QPS的两个杀手:一个是复杂操作,lrange,挺多的; value很大,2 byte,我之前用redis做大规模的缓存

  26.  
  27. 做商品详情页的cache,可能是需要把大串数据,拼接在一起,作为一个json串,大小可能都几k,几个byte

  28.  
  29. 2、水平扩容redis读节点,提升度吞吐量

  30.  
  31. 就按照上一节课讲解的,再在其他服务器上搭建redis从节点,单个从节点读请QPS在5万左右,两个redis从节点,所有的读请求打到两台机器上去,承载整个集群读QPS在10万+

 

 

这篇关于对主从 Redis 进行 QPS 压测的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1062851

相关文章

Redis 的 SUBSCRIBE命令详解

《Redis的SUBSCRIBE命令详解》Redis的SUBSCRIBE命令用于订阅一个或多个频道,以便接收发送到这些频道的消息,本文给大家介绍Redis的SUBSCRIBE命令,感兴趣的朋友跟随... 目录基本语法工作原理示例消息格式相关命令python 示例Redis 的 SUBSCRIBE 命令用于订

sky-take-out项目中Redis的使用示例详解

《sky-take-out项目中Redis的使用示例详解》SpringCache是Spring的缓存抽象层,通过注解简化缓存管理,支持Redis等提供者,适用于方法结果缓存、更新和删除操作,但无法实现... 目录Spring Cache主要特性核心注解1.@Cacheable2.@CachePut3.@Ca

Redis实现高效内存管理的示例代码

《Redis实现高效内存管理的示例代码》Redis内存管理是其核心功能之一,为了高效地利用内存,Redis采用了多种技术和策略,如优化的数据结构、内存分配策略、内存回收、数据压缩等,下面就来详细的介绍... 目录1. 内存分配策略jemalloc 的使用2. 数据压缩和编码ziplist示例代码3. 优化的

redis-sentinel基础概念及部署流程

《redis-sentinel基础概念及部署流程》RedisSentinel是Redis的高可用解决方案,通过监控主从节点、自动故障转移、通知机制及配置提供,实现集群故障恢复与服务持续可用,核心组件包... 目录一. 引言二. 核心功能三. 核心组件四. 故障转移流程五. 服务部署六. sentinel部署

基于Redis自动过期的流处理暂停机制

《基于Redis自动过期的流处理暂停机制》基于Redis自动过期的流处理暂停机制是一种高效、可靠且易于实现的解决方案,防止延时过大的数据影响实时处理自动恢复处理,以避免积压的数据影响实时性,下面就来详... 目录核心思路代码实现1. 初始化Redis连接和键前缀2. 接收数据时检查暂停状态3. 检测到延时过

Nginx中配置使用非默认80端口进行服务的完整指南

《Nginx中配置使用非默认80端口进行服务的完整指南》在实际生产环境中,我们经常需要将Nginx配置在其他端口上运行,本文将详细介绍如何在Nginx中配置使用非默认端口进行服务,希望对大家有所帮助... 目录一、为什么需要使用非默认端口二、配置Nginx使用非默认端口的基本方法2.1 修改listen指令

Redis实现分布式锁全过程

《Redis实现分布式锁全过程》文章介绍Redis实现分布式锁的方法,包括使用SETNX和EXPIRE命令确保互斥性与防死锁,Redisson客户端提供的便捷接口,以及Redlock算法通过多节点共识... 目录Redis实现分布式锁1. 分布式锁的基本原理2. 使用 Redis 实现分布式锁2.1 获取锁

Redis中哨兵机制和集群的区别及说明

《Redis中哨兵机制和集群的区别及说明》Redis哨兵通过主从复制实现高可用,适用于中小规模数据;集群采用分布式分片,支持动态扩展,适合大规模数据,哨兵管理简单但扩展性弱,集群性能更强但架构复杂,根... 目录一、架构设计与节点角色1. 哨兵机制(Sentinel)2. 集群(Cluster)二、数据分片

MySQL按时间维度对亿级数据表进行平滑分表

《MySQL按时间维度对亿级数据表进行平滑分表》本文将以一个真实的4亿数据表分表案例为基础,详细介绍如何在不影响线上业务的情况下,完成按时间维度分表的完整过程,感兴趣的小伙伴可以了解一下... 目录引言一、为什么我们需要分表1.1 单表数据量过大的问题1.2 分表方案选型二、分表前的准备工作2.1 数据评估

redis数据结构之String详解

《redis数据结构之String详解》Redis以String为基础类型,因C字符串效率低、非二进制安全等问题,采用SDS动态字符串实现高效存储,通过RedisObject封装,支持多种编码方式(如... 目录一、为什么Redis选String作为基础类型?二、SDS底层数据结构三、RedisObject