在 Ceph 集群搭建好后,我们想要知道我们的集群的性能到底怎样, 有没有以最好性能运行。以下几种方法可以粗略地测试集群的性能。


目录

  1. 获取基准性能统计数据
    1. 硬盘性能基准
    2. 网络性能基准
  2. 测试 Ceph 集群存储性能
  3. 测试 Ceph RBD 块设备性能
    1. 使用 RBD 内置性能测试工具
      1. 创建测试镜像
      2. 写入测试
      3. 读取测试
      4. 读写测试
    2. 使用 fio 对 RBD 进行测试
  4. 测试 Ceph 对象网关性能
    1. 使用 IOzone 对 RBD 进行测试
  5. CBT - Ceph 性能测试框架

获取基准性能统计数据

硬盘性能基准

最常见的也最简单的测试就是 dd,测试时记得忽略硬盘的 page cache

$ dd if=/dev/zero of=test bs=100M count=100 oflag=direct

如下图所示,这是在本机上的结果,最终给出的 157MB/s 即是硬盘的写入性能。

在集群上所有的硬盘上进行这一测试, 记录下测试结果。

网络性能基准

网络的带宽和延迟也是影响 Cluster 集群性能的重要因素。 iperf 是一个非常好的测试网络性能的工具,它使用了 client-server 连接来测试 TCP 和 UDP 的带宽。

iperf 需要安装在两个以上的节点上, 其中一个运行 server, 其他运行 client

[ceph@ceph1 ~]$ iperf -s
[ceph@ceph0 ~]$ iperf -c ceph1

可以看到,网络的传输带宽为 941 MB/s,网络所能承受的最大吞吐量.

有了一些基准数据之后, 就可以进行集群的性能测试了。 在进行测试之前,需要将所有的缓存禁掉。

$ sudo echo 3|sudo tee /proc/sys/vm/drop_caches && sudo sync

测试 Ceph 集群存储性能

Ceph 包含了 rados bench 命令, 目的就是为了测试 RADOS 存储集群的性能。 要测试其性能, 先创建一个测试的存储池, 再进行测试。

[ceph@cpeh0 ~]$ ceph rbd pool create rbd_bench 100 100
[ceph@ceph0 ~]$ rados bench -p rbd_bench 10 write--no-cleanup

结果如上图所示, 测试进行了 10s 的写入测试,测试结果给出了集群写入性能的相关指标。读取测试有两种,顺序 seq 和 随机 rand

[ceph@ceph0 ~]$ rados bench -p rbd_bench 10 seq
[ceph@ceph0 ~]$ rados bench -p rbd_bench 10 rand

可以加上 -t 选项来增加并行读写性能, 或者 -b 选项来改变写入对象的大小。可以同时对不同的 Pools 进行多次测试以观察多个客户端时的性能变化。下面是一个测试样例。

在测试完成后,可以将所有的测试数据清理掉。

[ceph@ceph0 ~]$ rados -p rbd_bench cleanup

测试 Ceph RBD 块设备性能

如果你是在用 Ceph 作为 OpenStack 等云计算平台的存储端,你可能比较关心 RBD 块设备的性能。 Ceph 本身已经包含 rbd 的高性能测试命令 rbd bench,也可以用流行的 I/O 性能测试工具 fio, 其现在也内置了对 RADOS 块设备的支持。

使用 RBD 内置性能测试工具

rbd bench 提供了一些选项可以指定测试的类型, 读写的大小,同时读写线程数等等, 下面是命令的简单用法。

$ rbd help bench
usage: rbd bench [--pool <pool>] [--image <image>] [--io-size <io-size>]
                 [--io-threads <io-threads>] [--io-total <io-total>]
                 [--io-pattern <io-pattern>]
                 [--rw-mix-read <rw-mix-read>] --io-type <io-type>
				 <image-spec>

Simple benchmark.

Positional arguments
  <image-spec>         image specification
                       (example: [<pool-name>/]<image-name>)

Optional arguments
  -p [--pool] arg    pool name
  --image arg          image name
  --io-size arg        IO size (in B/K/M/G/T) [default: 4K]
  --io-threads arg     ios in flight [default: 16]
  --io-total arg       total size for IO (in B/K/M/G/T) [default: 1G]
  --io-pattern arg     IO pattern (rand or seq) [default: seq]
  --rw-mix-read arg    read proportion in readwrite (<= 100) [default: 50]
  --io-type arg        IO type (read , write, or readwrite(rw))

创建测试镜像

[ceph@ceph0 ~]$ rbd create -p rbd_bench image01 --size 1024
[ceph@ceph0 ~]$ sudo rbd map image01 -p rbd_bench --name client.admin
[ceph@ceph0 ~]$ sudo mkfs.ext4 -m0 /dev/rbd/rbd_bench/image01
[ceph@ceph0 ~]$ sudo mkdir -p /mnt/rbd/rbd0
[ceph@ceph0 ~]$ sudo mount /dev/rbd/rbd_bench/image01 /mnt/rbd/rbd0

写入测试

  1. 顺序写入测试 --io-threads 16, --io-pattern seq, --io-type write
[ceph@ceph0 ~]$ rbd bench --io-pattern seq --io-type write --io-threads 16 rbd_bench/image01
bench  type write io_size 4096 io_threads 16 bytes 1073741824 pattern sequential
SEC       OPS   OPS/SEC   BYTES/SEC
  1     19216  18928.78  77532265.12
  2     33840  16885.47  69162868.74
  3     49872  16634.56  68135172.10
  4     64688  15932.72  65260420.77
  5     79696  15891.25  65090544.94
  6     94736  15155.24  62075871.22
  7    108352  14920.02  61112410.18
  8    123728  14770.92  60501690.27
  9    140064  15264.19  62522125.05
 10    156336  15380.00  62996487.97
 11    171088  15270.11  62546374.77
 12    183440  15017.32  61510925.55
 13    198176  14689.54  60168357.84
 14    212144  14355.43  58799859.19
 15    226336  13999.74  57342914.85
 16    235568  12775.66  52329122.65
 18    238512   8493.36  34788809.90
 19    240784   6812.79  27905191.13
 22    240944   3491.69  14301960.19
 23    241392   1705.06  6983942.13
 24    247104   1445.77  5921865.13
 25    248512   1449.25  5936119.55
 26    250928   1399.53  5732483.13
 27    255328   2846.57  11659558.50
 28    258416   3987.74  16333798.18
elapsed:    29  ops:   262144  ops/sec:  8991.53  bytes/sec: 36829303.18

写入速度为 36829303.18 B/s ~ 25 MB/s.
2. 随机写入测试 --io-threads 16, --io-pattern rand, --io-type write

[ceph@ceph0 ~]$ rbd bench --io-pattern rand --io-type write --io-threads 16 rbd_bench/image01
bench  type write io_size 4096 io_threads 16 bytes 1073741824 pattern random
  SEC       OPS   OPS/SEC   BYTES/SEC
    1      5984   5899.59  24164734.37
    2      6912   3369.59  13801824.44
    3      7712   2575.95  10551096.34
    4      8544   2118.25  8676341.63
    5      9376   1854.63  7596545.03
    6     10384    883.16  3617434.56
    7     11152    835.78  3423361.20
    8     12032    845.39  3462697.68
    9     12720    822.68  3369695.10
   10     13504    836.29  3425439.24
   ...    ...         ...   ...
  366    256832    754.22  3089269.17
  367    257648    758.82  3108106.35
  368    258464    784.48  3213250.05
  369    259200    779.69  3193598.51
  370    259840    779.38  3192349.72
  371    260480    730.61  2992574.34
  372    261376    740.70  3033895.78
  373    262064    717.12  2937314.62
elapsed:   392  ops:   262144  ops/sec:   668.29  bytes/sec: 2737297.63

随机写入速度为 2737297.63 B/s ~ 2.6 MB/s.

读取测试

  1. 顺序读取测试 --io-pattern seq, --io-type read, --io-threads 16
[ceph@ceph0 ~]$ rbd bench --io-pattern seq --io-type read rbd_bench/image01
bench  type read io_size 4096 io_threads 16 bytes 1073741824 pattern sequential
  SEC       OPS   OPS/SEC   BYTES/SEC
    1     11536  11586.54  47458466.83
    2     23776  11913.64  48798285.92
    3     36560  12203.97  49987468.84
    4     48048  12024.79  49253539.23
    5     60976  12205.49  49993691.45
    6     74800  12652.56  51824882.16
    7     88544  12953.35  53056935.50
    8    101360  12957.16  53072534.91
    9    113376  13065.35  53515678.78
   10    126800  13164.55  53921994.24
   11    139248  12889.35  52794796.51
   12    150336  12358.16  50619042.73
   13    163392  12408.65  50825812.14
   14    175696  12463.76  51051572.10
   15    188432  12326.17  50487973.23
   16    201600  12467.67  51067572.49
   17    212896  12511.76  51248176.37
   18    225136  12346.10  50569607.97
   19    237248  12307.70  50412356.02
   20    249136  12140.57  49727770.12
   21    260448  11771.73  48217007.26
elapsed:    21  ops:   262144  ops/sec: 12396.62  bytes/sec: 50776571.60

顺序读取速度为 50776571.60 B/s ~ 48.4 MB/s
2. 随机读取测试 --io-threads 16, --io-type read, --io-pattern rand.

[ceph@ceph0 ~]$ rbd bench --io-pattern rand --io-type read rbd_bench/image01
bench  type read io_size 4096 io_threads 16 bytes 1073741824 pattern random
  SEC       OPS   OPS/SEC   BYTES/sec:
    1     10304  10330.13  42312226.94
    2     20976  10501.05  43012303.11
    3     32624  10883.42  44578490.48
    4     45216  11310.61  46328267.65
    5     56896  11384.46  46630748.33
    6     69216  11782.18  48259790.95
    7     81344  12073.37  49452523.44
    8     93648  12204.57  49989908.40
    9    105904  12137.37  49714662.45
   10    117296  12077.35  49468843.58
   11    128624  11881.37  48666106.43
   12    140336  11798.18  48325325.73
   13    152480  11766.18  48194256.22
   14    163936  11606.18  47538908.72
   15    174944  11531.69  47233788.66
   16    186160  11504.68  47123168.62
   17    197376  11407.78  46726277.80
   18    209056  11314.98  46346176.24
   19    220784  11369.38  46568994.40
   20    232192  11449.38  46896668.16
   21    243792  11528.49  47220679.10
   22    255632  11650.98  47722406.03
elapsed:    22  ops:   262144  ops/sec: 11611.40  bytes/sec: 47560301.56

随机读取速度为 47560301.56 B/s ~ 45.4 MB/s

读写测试

  1. 顺序读写测试 --io-threads 16, --io-pattern seq, --io-type write
[ceph@cpeh0 ~]$ rbd bench --io-type rw --io-pattern seq rbd_bench/image01
bench  type readwrite read:write=50:50 io_size 4096 io_threads 16 bytes 1073741824 pattern sequential
 SEC       OPS   OPS/SEC   BYTES/SEC
   1      8640   8578.63  35138058.68
   2      9600   4793.53  19634290.32
   3     10432   3441.30  14095584.16
   4     11376   2846.52  11659356.30
   5     12304   2462.48  10086300.14
   6     13200    912.90  3739220.13
   7     14096    899.90  3686001.90
   8     14864    891.02  3649603.24
   9     15776    878.93  3600091.29
  10     17664   1073.05  4395223.66
 ...       ...      ...      ...
 211    241584    769.89  3153454.38
 212    242176    717.08  2937166.44
 213    242976    803.49  3291103.50
 214    243728    765.24  3134441.78
 215    244272    654.07  2679053.50
 216    244976    689.42  2823855.15
 217    245744    742.39  3040834.29
 218    249152   1232.71  5049184.45
 219    250624   1282.24  5252041.26
 220    252224   1641.93  6725329.65
 221    253872   1747.36  7157203.26
 222    254000   1637.41  6706848.82
 223    254112    960.11  3932592.52
 224    255296    999.13  4092418.19
 225    256016    776.08  3178824.42
 226    256976    626.81  2567395.36
 227    257856    782.45  3204925.96
 228    258880    963.99  3948515.16
 229    259584    866.60  3549578.30
 230    260384    864.59  3541367.22
 231    261424    881.65  3611231.11
elapsed:   237  ops:   262144  ops/sec:  1105.89  bytes/sec: 4529705.49
read_ops: 131275   read_ops/sec:   553.80   read_bytes/sec: 2268360.4
write_ops: 130869   write_ops/sec:   552.09   write_bytes/sec: 2261345.02

同时读写的性能比较差, 都只有 2 MB/s 的速度。。。
2. 随机读写测试 --io-threads 16, --io-pattern seq, --io-type rw

[ceph@cpeh0 ~]$ rbd bench --io-type rw --io-pattern rand rbd_bench/image01
bench  type readwrite read:write=50:50 io_size 4096 io_threads 16 bytes 1073741824 pattern random
  SEC       OPS   OPS/SEC   BYTES/SEC
    1      4224   4239.92  17366709.15
    2      8448   3990.49  16345065.31
    3      9072   3028.27  12403778.36
    4      9776   2444.29  10011799.28
    5     10304   2053.69  8411923.33
    6     11232   1381.95  5660465.62
    7     12032    733.81  3005688.85
    8     12928    770.72  3156880.89
    9     13696    777.45  3184453.41
   10     14448    832.78  3411073.28
  ...       ...       ...         ...
  271    253872    911.68  3734249.31
  272    254800    924.61  3787217.39
  273    255712    926.82  3796260.40
  274    256704    930.25  3810312.21
  275    257600    920.41  3769988.70
  276    258576    934.80  3828938.17
  277    259472    925.31  3790086.63
  278    260224    904.01  3702825.06
  279    260992    858.27  3515475.05
  280    261920    861.57  3528995.38
elapsed:   285  ops:   262144  ops/sec:   917.33  bytes/sec: 3757384.15
read_ops: 131548   read_ops/sec:   460.33   read_bytes/sec: 1885514.72
write_ops: 130596   write_ops/sec:   457.00   write_bytes/sec: 1871869.43

随机读写的性能也不好, 都在 1.8 MB/s 左右。。。

使用 fio 对 RBD 进行测试

fio 是一个通用的 I/O 性能测试工具,源码在 http://git.kernel.dk/fio.git。 源码里面带了一个 rbd.fio 的模板文件, 用来测试 RBD 块设备的 4K 随机写入性能。 需要根据 pool 和 image 的名字来修改相应的名字。

[ceph@ceph0 ~]$ git clone git://git.kernel.dk/fio.git && cd fio
[ceph@ceph0 ~]$ sudo yum install -y zlib-devel librados librbd-devel librados-devel libaio-devel
[ceph@ceph0 fio]$ ./configure && make -j 4 && sudo make install
[ceph@ceph0 fio]$ cat examples/rbd.fio
[global]
#logging
#write_iops_log=write_iops_log
#write_bw_log=write_bw_log
#write_lat_log=write_lat_log
ioengine=rbd
clientname=admin
pool=rbd
rbdname=fio_test
rw=randwrite
bs=4k

[rbd_iodepth32]
iodepth=32

可以看到, fio 给出的结果与之前的结果相近, 在 1.6 MS/s 左右。

测试 Ceph 对象网关性能

使用 swift-bench 可以测试 Ceph 对象网关的性能。 通过 pip 直接从源里安装 swift-bench

[ceph@ceph0 ~]$ sudo pip install swift-bench

这部分没有涉及。。。来自 Ceph。。

shell> sudo radosgw-admin user create --uid='benchmark' --display-name='benchmark'
shell> sudo radosgw-admin subuser create --uid='benchmark' --subuser=bencmark:swift --access=full
shell> sudo radosgw-admin key create --subuser=benchmark --key-type=swift
shell> radosgw-admin user modify --uid=benchmark --max-buckets=0
shell> cat > /tm/swift.conf < EOF
[bench]
auth = http://gateway-node/auth/v1.0
user = benchmark:swift
key  = guessme
auth_version = 1.0
EOF
shell> swift-bench -c 64 -s 4096 -n 1000 -g 100 /tmp/swift.conf

使用 IOzone 对 RBD 进行测试

…to.be.continued…

CBT - Ceph 性能测试框架

CBT 是 Ceph 官方提供的一个系统化的性能测试工具。 将会在 使用 CBT 来对 Ceph 集群进行性能测试 中介绍。。。