云数据库 Redis 性能深度评测（阿里云、华为云、腾讯云、百度智能云）

在当今的云服务市场中，阿里云、腾讯云、华为云和百度智能云都是领先的云服务提供商，他们都提供了全套的云数据库服务，其中 Redis属于RDS 之后第二被广泛应用的服务，本次测试旨在深入比较这四家云服务巨头在Redis云数据库性能方面的表现，为企业在选择合适的云数据库时提供重要的参考依据。

我们将针对阿里云、腾讯云、华为云和百度智能云的 Redis 云数据库进行全方位的性能测试，包括读写性能、并发处理能力等方面的测试。通过这些测试，我们将对这四家云服务提供商的Redis云数据库进行客观、公正的比较，以便企业能够根据自身业务需求选择最适合的云数据库服务。

通过本次测试，我们希望为企业提供一份详实的报告，以便企业在选择Redis云数据库服务时能够做出明智的决策。同时，我们也希望通过本次测试推动云服务提供商在技术和服务方面不断创新和提升，为企业提供更加优质、高效的云服务。

测试结论

标准版评测详细数据和结论

详细数据

标准版对比总结：

• 阿里云：整体性能排名第一，其中模型1中9/16个场景，模型3小Key读相关场景性能表现明显优于其它所有竞品

• 百度智能云：全部29个场景中，9个场景排名第一，19个场景性能表现优于腾讯云与华为云；

• 腾讯云：兼容Redis6.0，实际是1主1从3proxy部署架构，整体性能表现和华为差不多

• 华为云：兼容Redis6.0， 1主1从部署，整体性能表现和腾讯差不多

我们把测试数据加权之后，标准版的整体排名：阿里云(1.262)>百度智能云(1.053)>腾讯云(0.644)>华为云(0.537)

集群版评测结论

详细数据

集群版本对比结论

• 阿里云：在大key场景下性能退化严重，如hgetall、zrange、模型2、模型3涉及大key操作的场景性能打不上去

• 百度智能云：各场景性能表现都比较好，没有明显性能短板

• 腾讯云：在模型3-4KB以下场景性能均优于华为和百度

我们把测试数据加权之后，集群版本整体 排名：华为云(1.328)>百度智能云(1.197)>腾讯云(1.124)>阿里云(0.373)

测试环境

|--------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------|
| 厂商 | 云服务器1台 | 标准版8GB实例1台 | 集群版64GB实例1台 |
| 阿里云 Tair for Redis | 规格族:计算型 c8y 实例规格：ecs.c8y.4xlarge vCPU ：16 vCPU 内存:32 GiB 处理器主频/睿频:2.75 GHz/- 内网带宽:最高 16 Gbps | 付费模式：按量付费 商品类型：Tair for Redis 存储介质：内存 可用区类型：单可用区 实例类型：高可用 版本兼容性：Redis 6.0 架构类型:不启用集群 读写分离：关闭 分片规格：8GB 副本数：2副本 | 付费模式：按量付费 商品类型：Tair for Redis 存储介质：内存 可用区类型：单可用区 实例类型：高可用 版本兼容性：Redis 6.0 架构类型:启用集群 连接模式：代理模式 分片规格：8GB 副本数：2副本 分片数量：8 |
| 腾讯云 云数据库 Redis | 规格族:计算型C6 实例规格：C6.4XLARGE32 vCPU ：16 vCPU 内存:32 GiB 处理器主频/睿频:Intel Ice Lake(3.2GHz/3.5Ghz) 内网带宽:最高 18 Gbps | 计费模式：按量付费 产品版本：内存版 兼容版本：6.2 架构版本：标准架构 内存容量：8GB 副本数量：1个(1主1副本) | 计费模式：按量付费 产品版本：内存版 兼容版本：6.2 架构版本：集群架构 分片数量：8片 分片容量：8GB 副本数量：1个(1主1副本) |
| 华为云 分布式缓存服务Redis版 | 规格族:通用计算增强型c6s 实例规格：c6s.4xlarge.2 vCPU ：16 vCPU 内存:32 GiB 处理器主频/睿频:Intel Cascade Lake 2.6GHz 内网带宽:最高 7.5 Gbps | 计费模式：按需计费 缓存类型：Redis 版本号：6.0 实例类型：主备 CPU架构：x86计算 副本数：2 实例规格：redis.ha.xu1.large.r2.8（8GB） | 计费模式：按需计费 缓存类型：Redis 版本号：5.0 实例类型：Proxy集群 CPU架构：x86计算 规格选择模式：自定义分片 单分片容量：8GB 实例规格：redis.proxy.xu1.large.s8.64（64GB） |
| 百度智能云云数据库 SCS | 规格族:计算型C5 实例规格：bcc.c5.c16m32 vCPU ：16 vCPU 内存:32 GiB 处理器主频/睿频:Intel Xeon Platinum 8350C-2.6GHz 内网带宽:最高 6 Gbps | 计费模式：后付费 引擎类型： Redis 版本类型：社区版 架构类型：标准版 引擎版本：6.0 存储类型：高性能内存型 节点规格：cache.n1.large 副本数量： 2 | 计费模式：后付费 引擎类型： Redis 版本类型：企业版 架构类型：集群版 引擎版本：6.0 存储类型：高性能内存型 节点规格：cache.n1.large 分片数量：8片 副本数量： 2 |

测试工具

工具1：

压测工具：测试采用Redis Labs推出的多线程压测工具memtier_benchmark

使用方法：具体使用方法请参见 memtier_benchmark 虚机配置memtier-benchmark

使用到的测试选项：

./memtier_benchmark -s *** -a *** -p 8635 -c 4 -t 30 -n 1000000 --random-data --randomize --distinct-client-seed -d 128 --key-maximum=50331648 --key-minimum=1 --key-prefix= --ratio=1:0 --out-file=./result/result_small_128_set.log

工具2：

压测工具：开源Redis的redis-benchmark工具进行压测，它是Redis官方的性能测试工具

使用方法：为了确保工具支持--thread参数，测试时候使用最新的Redis版本进行编译，参见Redis开源项目

使用到的测试选项：

./src/redis-benchmark -h r-bp1s02ae14mr****.redis.rds.aliyuncs.com -p 6379 -a testaccount:Rp829dlwa -n 3000000 -r 10000000  -c 256 -t set -d 64 --threads 16

测试指标

• OPS：每秒执行的读写操作数，单位为次/秒。

评测模型

测试模型1------基本数据结构KEY密集型测试

|------------------|--------------------------------------|------------------------|
| workload模型 |||
| workload模型编号 | 测试模型 | 参数设置 |
| --command | Specify a command to send in quotes. | --command="${command}" |
| --test-time | Number of seconds to run the test | --test-time=300 |
| 数据模型 |||
| 数据模型编号 | 数据模型 | 参数设置 |
| value length-256 | 随机生成value，256字节 | -d 256 |

测试模型2------KEY分散读写测试

|--------------------|----------------------------------------|---------------------------|
| workload模型 |||
| workload模型编号 | 测试模型 | 参数设置 |
| 100% Write | 100%写操作（string set） | --ratio=1:0 |
| 100% Read | 100%读操作（string get） | --ratio=0:1 |
| 50% Read+50% Write | 50%读操作（string get）+ 50%写操作（string set） | --ratio=1:1 |
| 数据模型 |||
| 数据模型编号 | 数据模型 | 参数设置 |
| value length | 随机生成value，数据大小在指定的范围之内 | --data-size-range=1-10240 |

测试模型3------不同写入数据大小测试

|------------------|-------------------------------------------|--------------------|
| workload模型 |||
| workload模型编号 | 测试模型 | 参数设置 |
| -t | 测试命令，包含SET, GET | -t "${command}" |
| -n | Total number of requests (default 100000) | -n 3000000 |
| 数据模型 |||
| 数据模型编号 | 数据模型 | 参数设置 |
| value length-256 | value长度分别为16、128、256、1024、4096字节 | -d ${value_length} |

备注：模型3测试场景和工具参考阿里tair实例内存型（兼容Redis6.0）性能白皮书，需要使用redis-benchmark对SET、GET命令进行不同写入数据大小场景的测试，并给出测试指标。

测试方法

购买Redis实例，默认开启AOF和RDB，在云服务器上通过测试工具并发连接实例进行打压

模型1测试方法

固定参数：

bench_bin="memtier_benchmark"
thread=50
client=20
host="192.168.96.31"
port=6379
password="1234qwer"
data_size=256
test_time=300
key_maximum=300
key_prefix=""
command=$1
file=$2
start_time=$(date | awk '{print$4}')

echo "${bench_bin} -t ${thread} -c ${client} -s ${host} -p ${port} -a ${password} --distinct-client-seed --command="${command}"  --key-prefix="${key_prefix}" --key-minimum=1 --key-maximum=${key_maximum} --random-data --data-size=${data_size} --test-time=${test_time}  --out-file=out/${file}"

${bench_bin} -t ${thread} -c ${client} -s ${host} -p ${port} -a ${password} --distinct-client-seed --command="${command}"  --key-prefix="${key_prefix}" --key-minimum=1 --key-maximum=${key_maximum} --random-data --data-size=${data_size} --test-time=${test_time}  --out-file=out/${file}

end_time=$(date|awk '{print$4}')

echo "${command}  start: ${start_time}  end: ${end_time}" >> run.log

压测命令：

sh press.sh "set __key__ __data__"  set
sh press.sh "get __key__" get 
sh press.sh "del __key__" del 
sh press.sh "hset __key__ __key__ __data__"  hset
sh press.sh "hmset __key__ __key__ __data__ __key__ __data__ __key__ __data__" hmset
sh press.sh "hget __key__ __key__" hget
sh press.sh "hmget __key__ __key__ __key__" hmget
sh press.sh "hgetall __key__" hgetall
sh press.sh "hdel __key__ __key__" hdel
sh press.sh "zadd __key__  __key__  __data__" zadd
sh press.sh "zcard __key__"  zcard
sh press.sh "zcount __key__ 1 __key__" zcount       
sh press.sh "ZRANGE __key__ 0  __key__ WITHSCORES" zrange
sh press.sh "zrank __key__ __data__" zrank
sh press.sh "zscore __key__ __data__"  zscore
sh press.sh "zrem __key__ __key__" zrem

模型2测试方法

以8GB标准版为例，模型的性能指标的测试方法如下所示：

希望本次的测试可以给大家提供选型参考。当能云厂商更新也很快，性能上也是你追我赶，后面我们会持续关注各个云厂商的性能变化，动态更新测试结果。

欢迎大家访问百度智能云

• 测试场景1：100% Write模型通过执行如下命令，设置value长度为1-10240字节内的随机大小，记录性能指标。

• 测试场景2：100% Read模型通过执行如下命令，在写入的数据中均匀随机读取长度为1-10240字节的数据，记录性能指标。

• 测试场景3：50% Read+50% Write模型通过执行如下命令，记录性能指标。

  host=$1
  port=$2
  passwd=$3

  max_key=500000

  start_time=$(date | awk '{print$4}')
  ./memtier_benchmark -s ${host} -a ${passwd} -p ${port} -c 20 -t 50 --random-data --randomize --distinct-client-seed --data-size-range=1-10240 --key-maximum=${max_key} --key-minimum=1 --key-prefix= --ratio=1:0 --test-time=300 --out-file=out/${host}_${port}_set.log
  end_time=$(date|awk '{print$4}')

  echo "100% write  start: ${start_time}  end: ${end_time}" >> run.log

  start_time=$(date | awk '{print$4}')
  ./memtier_benchmark -s ${host} -a ${passwd} -p ${port}  -c 20 -t 50 --random-data --randomize --distinct-client-seed  --data-size-range=1-10240  --key-maximum=${max_key} --key-minimum=1 --key-prefix= --ratio=0:1 --test-time=300 --out-file=out/${host}_${port}_get.log
  end_time=$(date|awk '{print$4}')
  echo "100% read  start: ${start_time}  end: ${end_time}" >> run.log

  start_time=$(date | awk '{print$4}')
  ./memtier_benchmark -s ${host} -a ${passwd} -p ${port} -c 20 -t 50 --random-data --randomize --distinct-client-seed --data-size-range=1-10240  --key-maximum=${max_key} --key-minimum=1 --key-prefix= --ratio=1:1 --test-time=300 --out-file=out/${host}_${port}_set_get.log
  end_time=$(date|awk '{print$4}')
  echo "50% write + 50% read  start: ${start_time}  end: ${end_time}" >> run.log

模型3测试方法

使用开源的redis-benchmark工具进行压测，它是Redis官方的性能测试工具，为确保redis-benchmark工具支持**--threads** 参数，测试时推荐使用最新的Redis版本进行编译。

压测命令：
*

  host=$1
  port=$2
  passwd=$3
  key_range=1000000
  #16
  echo "before 16: redis-cli -h ${host} -p ${port} -a ${passwd}  flushall"
  redis-cli -h ${host} -p ${port} -a ${passwd}  flushall
  sleep 10

  start_time=$(date | awk '{print$4}')
  ./redis-benchmark -h ${host} -p ${port} -a ${passwd} -n 3000000 -r ${key_range}  -c 256 -t set -d 16 --threads 16 > out/16_set
  end_time=$(date|awk '{print$4}')
  echo "16 bytes_SET  start: ${start_time}  end: ${end_time}" >> run.log

  start_time=$(date | awk '{print$4}')
  ./redis-benchmark -h ${host} -p ${port} -a ${passwd} -n 3000000 -r ${key_range}  -c 256 -t get -d 16 --threads 16  > out/16_get
  end_time=$(date|awk '{print$4}')
  echo "16 bytes_GET  start: ${start_time}  end: ${end_time}" >> run.log

  #128
  echo "before 128: redis-cli -h ${host} -p ${port} -a ${passwd}  flushall"
  redis-cli -h ${host} -p ${port} -a ${passwd}  flushall
  sleep 10

  start_time=$(date | awk '{print$4}')
  ./redis-benchmark -h ${host} -p ${port} -a ${passwd} -n 3000000 -r ${key_range}  -c 256 -t set -d 128 --threads 16  > out/128_set
  end_time=$(date|awk '{print$4}')
  echo "128 bytes_SET  start: ${start_time}  end: ${end_time}" >> run.log

  start_time=$(date | awk '{print$4}')
  ./redis-benchmark -h ${host} -p ${port} -a ${passwd} -n 3000000 -r ${key_range}  -c 256 -t get -d 128 --threads 16  > out/128_get
  end_time=$(date|awk '{print$4}')
  echo "128 bytes_GET  start: ${start_time}  end: ${end_time}" >> run.log

  #256
  echo "before 256: redis-cli -h ${host} -p ${port} -a ${passwd}  flushall"
  redis-cli -h ${host} -p ${port} -a ${passwd}  flushall
  sleep 10

  start_time=$(date | awk '{print$4}')
  ./redis-benchmark -h ${host} -p ${port} -a ${passwd} -n 3000000 -r ${key_range}  -c 256 -t set -d 256 --threads 16  > out/256_set
  end_time=$(date|awk '{print$4}')
  echo "256 bytes_SET  start: ${start_time}  end: ${end_time}" >> run.log

  start_time=$(date | awk '{print$4}')
  ./redis-benchmark -h ${host} -p ${port} -a ${passwd} -n 3000000 -r ${key_range}  -c 256 -t get -d 256 --threads 16  > out/256_get
  end_time=$(date|awk '{print$4}')
  echo "256 bytes_GET  start: ${start_time}  end: ${end_time}" >> run.log

  #1024
  echo "before 1024: redis-cli -h ${host} -p ${port} -a ${passwd}  flushall"
  redis-cli -h ${host} -p ${port} -a ${passwd}  flushall
  sleep 10

  start_time=$(date | awk '{print$4}')
  ./redis-benchmark -h ${host} -p ${port} -a ${passwd} -n 3000000 -r ${key_range}  -c 256 -t set -d 1024 --threads 16  > out/1024_set
  end_time=$(date|awk '{print$4}')
  echo "1024 bytes_SET  start: ${start_time}  end: ${end_time}" >> run.log

  start_time=$(date | awk '{print$4}')
  ./redis-benchmark -h ${host} -p ${port} -a ${passwd} -n 3000000 -r ${key_range}  -c 256 -t get -d 1024 --threads 16  > out/1024_get
  end_time=$(date|awk '{print$4}')
  echo "1024 bytes_GET  start: ${start_time}  end: ${end_time}" >> run.log

  #4096
  echo "before 4096: redis-cli -h ${host} -p ${port} -a ${passwd}  flushall"
  redis-cli -h ${host} -p ${port} -a ${passwd}  flushall
  sleep 10

  start_time=$(date | awk '{print$4}')
  ./redis-benchmark -h ${host} -p ${port} -a ${passwd} -n 3000000 -r ${key_range}  -c 256 -t set -d 4096 --threads 16  > out/4096_set
  end_time=$(date|awk '{print$4}')
  echo "4096 bytes_SET  start: ${start_time}  end: ${end_time}" >> run.log

  start_time=$(date | awk '{print$4}')
  ./redis-benchmark -h ${host} -p ${port} -a ${passwd} -n 3000000 -r ${key_range}  -c 256 -t get -d 4096 --threads 16  > out/4096_get
  end_time=$(date|awk '{print$4}')
  echo "4096 bytes_GET  start: ${start_time}  end: ${end_time}" >> run.log

总体结论和分析

综合性能排名：百度智能云>腾讯云>华为云>阿里云

• 百度智能云标准版本和集群版本都排名第二，综合性能表现优于所有竞品，总体第一名，腾讯综合排名第二；

• 通过测试我们发现阿里和华为长板特长，短板也特短，尤其是阿里云大key场景存在性能问题，尤其集群版拉低整体评分，排名第四

• 华为排名第三。