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


目录

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

获取基准性能统计数据

硬盘性能基准

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

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

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


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

网络性能基准

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

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

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

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

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

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

测试 Ceph 集群存储性能

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

1
2
[ceph@cpeh0 ~]$ ceph rbd pool craete rbd_bench 100 100
[ceph@ceph0 ~]$ rbd bench -p rbd_bench write 10 --no-cleanup

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

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

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


在测试完成后,可以将所有的测试数据清理掉。
1
[ceph@ceph0 ~]$ rados -p rbd_bench cleanup

测试 Ceph RBD 块设备性能

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

使用 RBD 内置性能测试工具

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
$ 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))

创建测试镜像

1
2
3
4
5
[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
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    [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.

  1. 随机写入测试--io-threads 16, --io-pattern rand, --io-type write
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    [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
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    [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

  1. 随机读取测试--io-threads 16, --io-type read, --io-pattern rand.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    [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
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    [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 的速度。。。

  1. 随机读写测试--io-threads 16, --io-pattern seq, --io-type write
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    [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 的名字来修改相应的名字。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
[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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
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

CBT - Ceph 性能测试框架

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