• Ceph RBD 的实现原理与常规操作

    RBD

    RBD: Ceph’s RADOS Block Devices , Ceph block devices are thin-provisioned, resizable and store data striped over multiple OSDs in a Ceph cluster.

    Ceph RBD 是企业级的块设备存储解决方案，支持扩缩容、支持精简置备，具有 COW 特性，一个块设备（Volume）在 RADOS 中会被分割为若干个 Objects 储存。

    CEPH BLOCK DEVICE

    • Thin-provisioned
    • Images up to 16 exabytes
    • Configurable striping
    • In-memory caching
    • Snapshots
    • Copy-on-write cloning
    • Kernel driver support
    • KVM/libvirt support
    • Back-end for cloud solutions
    • Incremental backup
    • Disaster recovery (multisite asynchronous replication)

    RBD Pool 的创建与删除

    HELP：

    osd pool create <poolname> <int[0-]> {<int[0-]>} {replicated|erasure} {<erasure_code_create pool profile>} {<rule>} {<int>}

    创建一个 Pool rbd_pool 并初始化为 RBD 类型：

    1. [root@ceph-node1 ~]# ceph osd pool create rbd_pool 8 8
    2. pool 'rbd_pool' created
    3. [root@ceph-node1 ~]# ceph osd pool create rbd_pool02 8 8
    4. pool 'rbd_pool02' created
    5.  
    6. [root@ceph-node1 ~]# rbd pool init rbd_pool
    7. [root@ceph-node1 ~]# rbd pool init rbd_pool02

    NOTE：创建 Poo 时会指定 pg_num，官方推荐：

    • 少于 5 个 OSD， 设置 pg_num 为 128
    • 5~10 个 OSD，设置 pg_num 为 512
    • 10~50 个 OSD，设置 pg_num 为 4096
    • 超过 50 个OSD，可以应用 Ceph PGs per Pool Calculator 来进行计算

    查看 Pools 的 df 信息：

    1. [root@ceph-node1 ~]# rados df
    2. POOL_NAME              USED OBJECTS CLONES COPIES MISSING_ON_PRIMARY UNFOUND DEGRADED RD_OPS     RD WR_OPS      WR
    3. .rgw.root           2.2 KiB       6      0     18                  0       0        0     63 42 KiB      6   6 KiB
    4. default.rgw.control     0 B       8      0     24                  0       0        0      0    0 B      0     0 B
    5. default.rgw.log         0 B     207      0    621                  0       0        0  36870 36 MiB  24516     0 B
    6. default.rgw.meta        0 B       0      0      0                  0       0        0      0    0 B      0     0 B
    7. rbd_pool            114 MiB      44      0    132                  0       0        0   2434 49 MiB    843 223 MiB
    8.  
    9. total_objects    265
    10. total_used       9.4 GiB
    11. total_avail      81 GiB
    12. total_space      90 GiB

    查看每个 Pool 的 df 信息：

    1. [root@ceph-node1 ~]# ceph df
    2. GLOBAL:
    3.     SIZE       AVAIL      RAW USED     %RAW USED
    4.     90 GiB     79 GiB       11 GiB         12.39
    5. POOLS:
    6.     NAME                    ID     USED        %USED     MAX AVAIL     OBJECTS
    7.     .rgw.root               3      2.2 KiB         0        24 GiB           6
    8.     default.rgw.control     4          0 B         0        24 GiB           8
    9.     default.rgw.meta        5          0 B         0        24 GiB           0
    10.     default.rgw.log         6          0 B         0        24 GiB         207
    11.     images                  9       39 MiB      0.16        24 GiB           9
    12.     volumes                 10        36 B         0        24 GiB           5
    13.     vms                     11        19 B         0        24 GiB           3
    14.     backups                 12        19 B         0        24 GiB           2

    查看 Pool 的相关信息：

    1. # 查看 Pools 清单
    2. [root@ceph-node1 ~]# rados lspools
    3. rbd_pool
    4. rbd_pool02
    5.  
    6. # 查看 Pool 的 PG 和 PGP 数量
    7. [root@ceph-node1 ~]# ceph osd pool get rbd_pool pg_num
    8. pg_num: 8
    9. [root@ceph-node1 ~]# ceph osd pool get rbd_pool pgp_num
    10. pgp_num: 8
    11.  
    12. # 查看当前 OSD 状态
    13. root@ceph-node1 ~]# ceph osd dump | grep pool
    14. pool 1 'rbd_pool' replicated size 3 min_size 1 crush_rule 0 object_hash rjenkins pg_num 8 pgp_num 8 last_change 71 flags hashpspool,selfmanaged_snaps stripe_width 0 application rbd
    15. pool 3 '.rgw.root' replicated size 3 min_size 1 crush_rule 0 object_hash rjenkins pg_num 8 pgp_num 8 last_change 56 owner 18446744073709551615 flags hashpspool stripe_width 0 application rgw
    16. pool 4 'default.rgw.control' replicated size 3 min_size 1 crush_rule 0 object_hash rjenkins pg_num 8 pgp_num 8 last_change 59 owner 18446744073709551615 flags hashpspool stripe_width 0 application rgw
    17. pool 5 'default.rgw.meta' replicated size 3 min_size 1 crush_rule 0 object_hash rjenkins pg_num 8 pgp_num 8 last_change 61 owner 18446744073709551615 flags hashpspool stripe_width 0 application rgw
    18. pool 6 'default.rgw.log' replicated size 3 min_size 1 crush_rule 0 object_hash rjenkins pg_num 8 pgp_num 8 last_change 63 owner 18446744073709551615 flags hashpspool stripe_width 0 application rgw
    19.  
    20. # 查看 Pool 下属 Obejcts 的 OSD Map 信息，可以看出 Pool rbd_pool 的 Objects 具有 3 副本（PG 被映射到 3 个 OSD）
    21. [root@ceph-node1 ~]# ceph osd map rbd_pool rbd_info
    22. osdmap e53 pool 'rbd_pool' (1) object 'rbd_info' -> pg 1.ac0e573a (1.2) -> up ([4,0,8], p4) acting ([4,0,8], p4)
    23.  
    24. [root@ceph-node1 ~]# ceph osd map rbd_pool rbd_directory
    25. osdmap e53 pool 'rbd_pool' (1) object 'rbd_directory' -> pg 1.30a98c1c (1.4) -> up ([7,3,1], p7) acting ([7,3,1], p7)
    26.  
    27. [root@ceph-node1 ~]# ceph osd map rbd_pool rbd_id.volume01
    28. osdmap e53 pool 'rbd_pool' (1) object 'rbd_id.volume01' -> pg 1.8f1d799c (1.4) -> up ([7,3,1], p7) acting ([7,3,1], p7)

    删除一个 RBD 类型的 Pool：

    1. [root@ceph-node1 ~]# ceph osd pool delete rbd_pool02
    2. Error EPERM: WARNING: this will *PERMANENTLY DESTROY* all data stored in pool rbd_pool02.  If you are *ABSOLUTELY CERTAIN* that is what you want, pass the pool name *twice*, followed by --yes-i-really-really-mean-it.
    3.  
    4. [root@ceph-node1 ~]# ceph osd pool delete rbd_pool02 rbd_pool02 --yes-i-really-really-mean-it
    5. Error EPERM: pool deletion is disabled; you must first set the mon_allow_pool_delete config option to true before you can destroy a pool

    上述表示删除失败，Pool 的删除是一个风险级别非常高的操作，所以 Ceph 为该操作设定了一个配置项，我们修改配置运行删除 Pool：

    1. # 只允许当前客户端执行删除操作，所以直接修改 /etc/ceph/ceph.conf
    2. [mon]
    3. mon allow pool delete = true
    4.  
    5. $ systemctl restart ceph-mon.target

    再次删除 Pool：

    1. [root@ceph-node1 ~]# ceph osd pool delete rbd_pool02 rbd_pool02 --yes-i-really-really-mean-it
    2. pool 'rbd_pool02' removed

    设置 Pool 的配额：

    1. # 设置允许最大 Objects 数量为 100
    2. ceph osd pool set-quota test-pool max_objects 100
    3.  
    4. # 设置允许最大容量限制为 10GB
    5. ceph osd pool set-quota test-pool max_bytes $((10 * 1024 * 1024 * 1024))
    6.  
    7. # 取消配额限制只需要把对应值设为 0 即可

    Pool 的重命名：

    ceph osd pool rename test-pool test-pool-new

    创建/删除 Pool Snapshot：

    1. # 创建
    2. ceph osd pool mksnap test-pool test-pool-snapshot
    3.  
    4. # 删除
    5. ceph osd pool rmsnap test-pool test-pool-snapshot

    NOTE：Ceph 有两种 Snapshot 类型，这两种类型是互斥的，在存在 Self Managed Snapshot 的 Pool 中不能再执行 Pool Snapshot，反之亦然。

    • Pool Snapshot：对 Pool 执行快照
    • Self Managed Snapshot：对 RBD 块设备执行快照

    设置 Pool 的元数据：

    1. eph osd pool set {pool-name} {key} {value}
    2.  
    3. # 设置 Pool 的 PG 副本数量为 3
    4. ceph osd pool set test-pool size 3

    块设备的创建与删除

    要创建 RBD 块设备，首先需要登录到 Ceph Cluster 的任意 MON 节点，或登录到具有 Ceph Cluster 管理员权限的 Host，或 Ceph 客户端上。下面我们直接在 MON 节点上执行操作。

    指定 RBD Pool 创建块设备：

    1. [root@ceph-node1 ~]# rbd create rbd_pool/volume01 --size 1024
    2. [root@ceph-node1 ~]# rbd create rbd_pool/volume02 --size 1024
    3. [root@ceph-node1 ~]# rbd create rbd_pool/volume03 --size 1024

    NOTE：如果不指定 RBD 类型的 Pool Name，则默认为 rbd，所以首选需要有一个 Pool rbd。

    查看块设备信息：

    1. [root@ceph-node1 ~]# rbd --image rbd_pool/volume01 info
    2. rbd image 'volume01':
    3.     size 1 GiB in 256 objects
    4.     order 22 (4 MiB objects)
    5.     id: 11126b8b4567
    6.     block_name_prefix: rbd_data.11126b8b4567
    7.     format: 2
    8.     features: layering, exclusive-lock, object-map, fast-diff, deep-flatten
    9.     op_features:
    10.     flags:
    11.     create_timestamp: Tue Apr 23 07:30:57 2019
    12.  
    13. # size：块设备大小
    14. # order：Object 大小，这里 22 表示 2**22 即 4MiB
    15. # block_name_prefix：块设备的 Ceph Cluster 全局唯一标示
    16. # format：块设备格式，有 1、2 两种类型
    17. # features：卷特性，细分为
    18. # - layering：支持分层
    19. # - striping：支持条带化 v2
    20. # - exclusive-lock：支持独占锁
    21. # - object-map：支持对象映射索引，依赖 exclusive-lock
    22. # - fast-diff：支持快速计算差异，依赖 object-map
    23. # - deep-flatten：支持快照扁平化
    24. # - journaling：支持记录 IO 操作，依赖独占锁

    查看 Pool 下属的块设备的相关 Obejcts：

    1. [root@ceph-node1 ~]# rados -p rbd_pool ls
    2. ...
    3. rbd_directory
    4. rbd_id.volume01
    5.  
    6. # rbd_id.volume01：保存了 volume01 自己的 block_name_prefix
    7. # rbd_directory：保存了这个 Pool 下属所有块设备的索引

    获取 Pool 下的一个 Objects 并查看其内容：

    1. root@ceph-node1 ~]# rados -p rbd_pool get rbd_info rbd_info
    2.  
    3. [root@ceph-node1 ~]# ls
    4. rbd_info
    5.  
    6. [root@ceph-node1 ~]# hexdump -vC rbd_info
    7. 00000000  6f 76 65 72 77 72 69 74  65 20 76 61 6c 69 64 61  |overwrite valida|
    8. 00000010  74 65 64                                          |ted|
    9. 00000013

    删除一个块设备：

    1. [root@ceph-node1 ~]# rbd ls rbd_pool
    2. volume01
    3. volume02
    4. volume03
    5.  
    6. [root@ceph-node1 ~]# rbd rm volume03 -p rbd_pool
    7. Removing image: 100% complete...done.
    8.  
    9. [root@ceph-node1 ~]# rbd ls rbd_pool
    10. volume01
    11. volume02

    块设备的挂载与卸载

    RBD 的驱动程序已经被集成到 Linux 内核（2.6.39 或更高版本），将 Linux 操作系统作为客户端挂载卷的前提是加载 RBD 内核模块，下面我们首先将卷挂载到 ceph-node1，因为 ceph-node1 就是一个原生的客户端，不需要额外操作。

    映射块设备到客户端本地：

    1. [root@ceph-node1 ~]# lsmod | grep rbd
    2. rbd                    83640  2
    3. libceph               306625  1 rbd
    4.  
    5. [root@ceph-node1 ~]# rbd map rbd_pool/volume01
    6. rbd: sysfs write failed
    7. RBD image feature set mismatch. You can disable features unsupported by the kernel with "rbd feature disable rbd_pool/volume01 object-map fast-diff deep-flatten".
    8. In some cases useful info is found in syslog - try "dmesg | tail".
    9. rbd: map failed: (6) No such device or address

    这里执行映射失败了，原因是因为客户端内核版本较低，无法支持卷的全部特性，可以通过以下修改来解决。

    设定 Ceph 的全局默认 RBD 块设备特性清单：

    1. $ vi /etc/ceph/ceph.conf
    2. [global]
    3. ...
    4. rbd_default_features = 1
    5.  
    6. $ ceph-deploy --overwrite-conf admin ceph-node1 ceph-node2 ceph-node3

    或者在创建块设备的时候单独指定块设备特性：

    rbd create rbd_pool/volume03 --size 1024 --image-format 1 --image-feature layering

    或者关闭内核不支持的块设备特性之后再映射：

    1. [root@ceph-node1 ~]# rbd info rbd_pool/volume01
    2. rbd image 'volume01':
    3.     size 1 GiB in 256 objects
    4.     order 22 (4 MiB objects)
    5.     id: 11126b8b4567
    6.     block_name_prefix: rbd_data.11126b8b4567
    7.     format: 2
    8.     features: layering, exclusive-lock, object-map, fast-diff, deep-flatten
    9.     op_features:
    10.     flags:
    11.     create_timestamp: Tue Apr 23 07:30:57 2019
    12.     
    13. [root@ceph-node1 ~]# rbd feature disable rbd_pool/volume01 object-map fast-diff deep-flatten
    14. [root@ceph-node1 ~]# rbd feature disable rbd_pool/volume02 object-map fast-diff deep-flatten
    15.  
    16. [root@ceph-node1 ~]# rbd info rbd_pool/volume01
    17. rbd image 'volume01':
    18.     size 1 GiB in 256 objects
    19.     order 22 (4 MiB objects)
    20.     id: 11126b8b4567
    21.     block_name_prefix: rbd_data.11126b8b4567
    22.     format: 2
    23.     features: layering, exclusive-lock
    24.     op_features:
    25.     flags:
    26.     create_timestamp: Tue Apr 23 07:30:57 2019
    27.  
    28. [root@ceph-node1 ~]# rbd map rbd_pool/volume01
    29. /dev/rbd0

    查看客户端本地已映射的块设备：

    1. [root@ceph-node1 ~]# rbd showmapped
    2. id pool     image    snap device
    3. 0  rbd_pool volume01 -    /dev/rbd0
    4.  
    5. [root@ceph-node1 ~]# lsblk | grep rbd0
    6. rbd0                                                                                                  252:0    0    1G  0 disk

    块设备映射到本地之后就等同于一个裸设备，需要分区格式化以及创建文件系统：

    1. [root@ceph-node1 ~]# mkfs.xfs /dev/rbd0
    2. meta-data=/dev/rbd0              isize=512    agcount=8, agsize=32768 blks
    3.          =                       sectsz=512   attr=2, projid32bit=1
    4.          =                       crc=1        finobt=0, sparse=0
    5. data     =                       bsize=4096   blocks=262144, imaxpct=25
    6.          =                       sunit=1024   swidth=1024 blks
    7. naming   =version 2              bsize=4096   ascii-ci=0 ftype=1
    8. log      =internal log           bsize=4096   blocks=2560, version=2
    9.          =                       sectsz=512   sunit=8 blks, lazy-count=1
    10. realtime =none                   extsz=4096   blocks=0, rtextents=0

    数据最终在 OSDs 上以 Object 的形式储存，Obejcts 的前缀为块设备的 block_name_prefix。随着写入的数据越多，Objects 的数量也会越多：

    1. [root@ceph-node1 deploy]# rados ls -p rbd_pool | grep rbd_data.121896b8b4567
    2. rbd_data.121896b8b4567.0000000000000080
    3. rbd_data.121896b8b4567.00000000000000a0
    4. rbd_data.121896b8b4567.0000000000000082
    5. rbd_data.121896b8b4567.00000000000000e0
    6. rbd_data.121896b8b4567.00000000000000ff
    7. rbd_data.121896b8b4567.0000000000000081
    8. rbd_data.121896b8b4567.0000000000000040
    9. rbd_data.121896b8b4567.0000000000000020
    10. rbd_data.121896b8b4567.0000000000000000
    11. rbd_data.121896b8b4567.00000000000000c0
    12. rbd_data.121896b8b4567.0000000000000060
    13. rbd_data.121896b8b4567.0000000000000001

    NOTE：而且这些块设备对应的 Objects 的后缀是是以 16 进制编码的，Object 的命名规则为 block_name_prefix+index。而且 index range [0x00, 0xff] 就是十进制的 256，表示该块设备的 Size 具有 256 个 Objects。

    1. [root@ceph-node1 ~]# rbd --image rbd_pool/volume01 info
    2. rbd image 'volume01':
    3.     size 1 GiB in 256 objects

    但很显然，现在实际上并不存在 256 个 Objects，这是因为 Ceph RBD 是精简置备的，并非是完成创建卷时就已经把块设备 Size 对应的 256 个 Objects 都准备好了，Objects 的数量是随着实际数据的写入而逐渐增长的。并且上述的 12 个 Objects 仅仅是格式化 XFS 文件系统时生成的。

    mount 块设备并写入数据：

    1. [root@ceph-node1 ~]# mkdir -pv /mnt/volume01
    2.  
    3. [root@ceph-node1 ~]# mount /dev/rbd0 /mnt/volume01
    4.  
    5. [root@ceph-node1 ~]# dd if=/dev/zero of=/mnt/volume01/fi1e1 count=10 bs=1M
    6. 10+0 records in
    7. 10+0 records out
    8. 10485760 bytes (10 MB) copied, 0.0129169 s, 812 MB/s
    9.  
    10. [root@ceph-node1 deploy]# rados ls -p rbd_pool | grep rbd_data.121896b8b4567 | wc -l
    11. 37

    可以看见，块设备的 Objects 动态增长了。

    我们不妨看看块设备 volume01 的第一、第二个 Objects 的内容：

    1. [root@ceph-node1 ~]# rados -p rbd_pool get rbd_data.121896b8b4567.0000000000000000 rbd_data.121896b8b4567.0000000000000000
    2. [root@ceph-node1 ~]# rados -p rbd_pool get rbd_data.121896b8b4567.0000000000000001 rbd_data.121896b8b4567.0000000000000001
    3.  
    4. [root@ceph-node1 ~]# ll -lht
    5. total 172K
    6. -rw-r--r--  1 root root  32K Apr 24 06:30 rbd_data.121896b8b4567.0000000000000001
    7. -rw-r--r--  1 root root 128K Apr 24 06:30 rbd_data.121896b8b4567.0000000000000000
    8.  
    9. [root@ceph-node1 ~]# hexdump -vC rbd_data.121896b8b4567.0000000000000000 | more
    10. 00000000  58 46 53 42 00 00 10 00  00 00 00 00 00 04 00 00  |XFSB............|
    11. ...

    有两点信息值得我们关注，首先，从第一个 Objects 的内容可以看出它的确是 mkfs.xfs 文件系统时创建的，而且这样的数据就是 XFS 文件系统的格式；再一个，可见 Object0、Object1 的 Size 都没有达到 4MiB，但却创建了更多的 Objects。这是因为客户端将原始数据分片之后是轮询储存到 Object Set 的，而不是存满了一个 Object 再继续存到下一个 Object 的（!!! 这里有待验证，因为 volume01 没有开启条带化特性）。

    卸载块设备：

    1. [root@controller ~]# umount /mnt/volume01/
    2.  
    3. root@ceph-node1 deploy]# rbd showmapped
    4. id pool     image    snap device
    5. 1  rbd_pool volume01 -    /dev/rbd1
    6.  
    7. [root@ceph-node1 deploy]# rbd unmap rbd_pool/volume01
    8.  
    9. [root@ceph-node1 deploy]# rbd showmapped

    关于 RBD 块设备与 XFS 的一个有趣描述：

    RBD 其实是一个完完整整的块设备，如果把 1G 的块想成一个 1024 层楼的高楼的话，xfs 可以想象成住在这个大楼里的楼管，它只能在大楼里面，也就只能看到这 1024 层的房子，楼管自然可以安排所有的住户（文件或文件名），住在哪一层哪一间，睡在地板还是天花板（文件偏移量），隔壁的楼管叫做 ext4，虽然住在一模一样的大楼里，但是它们有着自己的安排策略，这就是文件系统如果组织文件的一个比喻。某一天拆迁大队长跑来说，我不管你们（xfs or ext4）是怎么安排的，盖这么高的楼是想做什么，然后大队长把这 1024 层房子，每 4 层（4MiB）砍了一刀，一共砍成了 256 个四层，然后一起打包带走了，运到了一个叫做 Ceph 的小区里面，放眼望去，这个小区里面的房子最高也就四层（填满的），而有些才打了地基（还没写内容）。

    新建客户端

    这里我们将 OpenStack 的 Controller Node 作为客户端，首先加载 rbd 内核模块：

    1. [root@controller ~]# uname -r
    2. 3.10.0-957.10.1.el7.x86_64
    3.  
    4. [root@controller ~]# modprobe rbd
    5. [root@controller ~]# lsmod | grep rbd
    6. rbd                    83640  0
    7. libceph               306625  1 rbd

    为了授予客户端访问 Ceph Cluster 的权限，需要将管理员密钥环和配置文件拷贝到客户端上。客户端与 Ceph Cluster 之间的身份验证基于这个密钥环，这里我们使用 admin keyring，使客户端拥有完全访问 Ceph Cluster 的权限。合理的做法应该是创建权限集有限的密钥环分发给非管理员客户端。下面我们依旧通过 ceph-deploy 工具来完成客户端的安装与授权。

    • 在 Controller 上配置 Ceph Mimic YUM 源

    • Controller 与 Ceph Deploy 节点免密登录：

    [root@ceph-node1 deploy]# ssh-copy-id -i ~/.ssh/id_rsa.pub root@controller
    • 在 Controller 上安装客户端软件：
    ceph-deploy install controller
    • 将密钥环和配置文件拷贝到 Controller
    ceph-deploy --overwrite-conf admin controller

    LOG：

    [ceph_deploy.admin][DEBUG ] Pushing admin keys and conf to controller
    • 在客户端查询 Ceph Cluster 状态
    1. [root@controller ~]# ceph -s
    2.   cluster:
    3.     id:     d82f0b96-6a69-4f7f-9d79-73d5bac7dd6c
    4.     health: HEALTH_WARN
    5.             too few PGs per OSD (2 < min 30)
    6.  
    7.   services:
    8.     mon: 3 daemons, quorum ceph-node1,ceph-node2,ceph-node3
    9.     mgr: ceph-node1(active), standbys: ceph-node2, ceph-node3
    10.     osd: 9 osds: 9 up, 9 in
    11.  
    12.   data:
    13.     pools:   1 pools, 8 pgs
    14.     objects: 40  objects, 84 MiB
    15.     usage:   9.3 GiB used, 81 GiB / 90 GiB avail
    16.     pgs:     8 active+clean
    • 在 Controller 客户端挂载卷
    1. [root@controller ~]# rbd map rbd_pool/volume02
    2. /dev/rbd0
    3.  
    4. [root@controller ~]# rbd showmapped
    5. id pool     image    snap device
    6. 0  rbd_pool volume02 -    /dev/rbd0
    7.  
    8. [root@controller ~]# mkfs.xfs /dev/rbd0
    9. meta-data=/dev/rbd0              isize=512    agcount=8, agsize=32768 blks
    10.          =                       sectsz=512   attr=2, projid32bit=1
    11.          =                       crc=1        finobt=0, sparse=0
    12. data     =                       bsize=4096   blocks=262144, imaxpct=25
    13.          =                       sunit=1024   swidth=1024 blks
    14. naming   =version 2              bsize=4096   ascii-ci=0 ftype=1
    15. log      =internal log           bsize=4096   blocks=2560, version=2
    16.          =                       sectsz=512   sunit=8 blks, lazy-count=1
    17. realtime =none                   extsz=4096   blocks=0, rtextents=0
    18.  
    19. [root@controller ~]# mkdir -pv /mnt/volume02
    20. mkdir: created directory ‘/mnt/volume02’
    21.  
    22. [root@controller ~]# mount /dev/rbd0 /mnt/volume02
    23.  
    24. [root@controller ~]# df -Th
    25. Filesystem              Type      Size  Used Avail Use% Mounted on
    26. /dev/mapper/centos-root xfs       196G  3.2G  193G   2% /
    27. devtmpfs                devtmpfs  9.8G     0  9.8G   0% /dev
    28. tmpfs                   tmpfs     9.8G     0  9.8G   0% /dev/shm
    29. tmpfs                   tmpfs     9.8G  938M  8.9G  10% /run
    30. tmpfs                   tmpfs     9.8G     0  9.8G   0% /sys/fs/cgroup
    31. /dev/sda1               xfs       197M  165M   32M  84% /boot
    32. tmpfs                   tmpfs     2.0G     0  2.0G   0% /run/user/0
    33. /dev/rbd0               xfs      1014M   43M  972M   5% /mnt/volume02
    34.  
    35. [root@controller ~]# dd if=/dev/zero of=/mnt/volume02/fi1e1 count=10 bs=1M
    36. 10+0 records in
    37. 10+0 records out
    38. 10485760 bytes (10 MB) copied, 0.0100852 s, 1.0 GB/s

    块设备的扩缩容

    块设备扩容：

    1. [root@ceph-node1 deploy]# rbd resize rbd_pool/volume01 --size 2048
    2. Resizing image: 100% complete...done.
    3.  
    4. [root@ceph-node1 ~]# rbd info rbd_pool/volume01
    5. rbd image 'volume01':
    6.     size 2 GiB in 512 objects
    7.     order 22 (4 MiB objects)
    8.     id: 11126b8b4567
    9.     block_name_prefix: rbd_data.11126b8b4567
    10.     format: 2
    11.     features: layering, exclusive-lock
    12.     op_features:
    13.     flags:
    14.     create_timestamp: Tue Apr 23 07:30:57 2019

    如果已经被挂载了，还要手动检查新的容量是否被内核接收，刷新一下文件系统的大小：

    1. [root@ceph-node1 ~]# df -Th
    2. ...
    3. /dev/rbd0               xfs      1014M  103M  912M  11% /mnt/volume01
    4.  
    5. [root@ceph-node1 ~]# xfs_growfs -d /mnt/volume01/
    6. meta-data=/dev/rbd0              isize=512    agcount=8, agsize=32768 blks
    7.          =                       sectsz=512   attr=2, projid32bit=1
    8.          =                       crc=1        finobt=0 spinodes=0
    9. data     =                       bsize=4096   blocks=262144, imaxpct=25
    10.          =                       sunit=1024   swidth=1024 blks
    11. naming   =version 2              bsize=4096   ascii-ci=0 ftype=1
    12. log      =internal               bsize=4096   blocks=2560, version=2
    13.          =                       sectsz=512   sunit=8 blks, lazy-count=1
    14. realtime =none                   extsz=4096   blocks=0, rtextents=0
    15. data blocks changed from 262144 to 524288
    16.  
    17. [root@ceph-node1 ~]# df -Th
    18. ...
    19. /dev/rbd0               xfs       2.0G  103M  1.9G   6% /mnt/volume01

    RBD 块设备的 Format 1 VS Format 2

    众所周知，RBD 块设备有两种格式，不同的格式包含了不同块设备特性集合：

    • Format 1：Hammer，rbd_default_features = 3
    • Format 2：Jewel，rbd_default_features = 61

    Features 编号：配置项 rbd_default_features 的值就是由下列编号相加得到的：
    NOTE：Only applies to format 2 images

    • +1 for layering,
    • +2 for striping v2,
    • +4 for exclusive lock,
    • +8 for object map
    • +16 for fast-diff,
    • +32 for deep-flatten,
    • +64 for journaling

    块设备的快照、克隆、恢复

    Ceph 块设备的快照是一个基于时间点的、只读的块设备镜像副本，可以通过创建快照来保存块设备在某一时刻的状态，并且支持创建多次快照，所以快照功能也被称之为 Time Machine（时间机器）。

    Ceph RBD 应用的快照技术为 COW（写时复制），通过写时复制可以在保持原始镜像数据不被修改的情况下，得到一个新的镜像或称为快照文件，而新的镜像中储存化了新数据的变更。可见，快照的执行是非常快的，因为它仅更新了块设备的元数据，例如：添加了快照 ID。Ceph RBD 的分层特性与 QCOW2 镜像文件具有一样的特征，更多的 COW 工作原理，请浏览《再谈 COW、ROW 快照技术》。

    注：基于具体的实现差异，快照未必会以实际的文件形式而存在。所以，这里 “快照” 的语义表示变更的新数据。

    基于 COW 的链式快照：
    在这里插入图片描述
    创建快照：

    $ rbd snap create rbd_pool/volume01@snap01

    查看快照：

    1. [root@ceph-node1 ~]# rbd snap ls rbd_pool/volume01
    2. SNAPID NAME    SIZE TIMESTAMP
    3.      4 snap01 2 GiB Tue Apr 23 23:50:23 2019

    删除指定快照：

    $ rbd snap rm rbd_pool/volume01@snap01

    删除全部快照：

    1. [root@ceph-node1 ~]# rbd snap purge rbd_pool/volume01
    2. Removing all snapshots: 100% complete...done.

    克隆就是基于快照恢复出一个新的块设备，它的执行速度同样很快，只会修改了块设备的元数据，例如：添加了 parent 信息。为了便于理解，我们首先统一一下术语定义：

    • 块设备，镜像（RBD Image）：Ceph RBD 块设备的统称。
    • 原始镜像，模板镜像：被执行快照的块设备。
    • COW 副本镜像：通过某一个快照克隆出来的块设备。

    NOTE：快照和克隆的区别在于，克隆利用了快照的 COW 分层特性，拷贝了指定快照的数据并转换为一个被 Ceph 认可的新的块设备。
    在这里插入图片描述
    得益于 Ceph RBD 的分层特性，使得对接 Ceph 存储的 Openstack 能够在短时间之内快速地启动数百台虚拟机，而虚拟机磁盘的本质就是 COW 副本镜像，它保存了 GuestOS 更改的数据。

    创建 RBD 块设备：

    1. [root@ceph-node1 ~]# rbd create rbd_pool/volume03 --size 1024 --image-format 2
    2.  
    3. [root@ceph-node1 ~]# rbd ls rbd_pool
    4. volume01
    5. volume02
    6. volume03
    7.  
    8. [root@ceph-node1 ~]# rbd info rbd_pool/volume03
    9. rbd image 'volume03':
    10. 	size 1 GiB in 256 objects
    11. 	order 22 (4 MiB objects)
    12. 	id: 12bb6b8b4567
    13. 	block_name_prefix: rbd_data.12bb6b8b4567
    14. 	format: 2
    15. 	features: layering
    16. 	op_features:
    17. 	flags:
    18. 	create_timestamp: Wed Apr 24 03:53:28 2019

    执行快照：

    1. [root@ceph-node1 ~]# rbd snap create rbd_pool/volume03@snap01
    2.  
    3. [root@ceph-node1 ~]# rbd snap ls rbd_pool/volume03
    4. SNAPID NAME    SIZE TIMESTAMP
    5.      8 snap01 1 GiB Wed Apr 24 03:54:53 2019

    将快照设为保护（不可被删除）状态，此时的快照就是原始镜像：

    rbd snap protect rbd_pool/volume03@snap01

    执行克隆操作，得到 COW 副本镜像，包含了父镜像信息：

    1. [root@ceph-node1 ~]# rbd clone rbd_pool/volume03@snap01 rbd_pool/vol01_from_volume03
    2.  
    3. [root@ceph-node1 ~]# rbd ls rbd_pool
    4. vol01_from_volume03
    5. volume01
    6. volume02
    7. volume03
    8.  
    9. [root@ceph-node1 ~]# rbd info rbd_pool/vol01_from_volume03
    10. rbd image 'vol01_from_volume03':
    11. 	size 1 GiB in 256 objects
    12. 	order 22 (4 MiB objects)
    13. 	id: faf86b8b4567
    14. 	block_name_prefix: rbd_data.faf86b8b4567
    15. 	format: 2
    16. 	features: layering
    17. 	op_features:
    18. 	flags:
    19. 	create_timestamp: Wed Apr 24 03:56:36 2019
    20. 	parent: rbd_pool/volume03@snap01
    21. 	overlap: 1 GiB

    执行 COW 副本镜像的扁平化，使其不再依赖父镜像，自身就具有块设备的完整数据（旧+新）：

    1. [root@ceph-node1 ~]# rbd flatten rbd_pool/vol01_from_volume03
    2. Image flatten: 100% complete...done.
    3.  
    4. [root@ceph-node1 ~]# rbd info rbd_pool/vol01_from_volume03
    5. rbd image 'vol01_from_volume03':
    6. 	size 1 GiB in 256 objects
    7. 	order 22 (4 MiB objects)
    8. 	id: faf86b8b4567
    9. 	block_name_prefix: rbd_data.faf86b8b4567
    10. 	format: 2
    11. 	features: layering
    12. 	op_features:
    13. 	flags:
    14. 	create_timestamp: Wed Apr 24 03:56:36 2019

    解除保护并删除快照：

    1. [root@ceph-node1 ~]# rbd snap unprotect rbd_pool/volume03@snap01
    2.  
    3. [root@ceph-node1 ~]# rbd snap rm rbd_pool/volume03@snap01
    4. Removing snap: 100% complete...done.
    5.  
    6. [root@ceph-node1 ~]# rbd snap ls rbd_pool/volume03

    恢复一个快照就是进行一个 “时刻穿越”，将块设备还原到某个特定时间点的状态，所以 Ceph 的恢复指令选择了使用 rollback 一词：

    1. [root@ceph-node1 ~]# rbd snap rollback rbd_pool/volume01@snap01
    2. Rolling back to snapshot: 100% complete...done.

    NOTE：如果块设备已经被挂载，那么需要 re-mount 以刷新文件系统状态

    块设备的 I/O 模型

    在这里插入图片描述

    1. 客户端应用 librbd 库创建一个块设备，并向块设备写入数据。
    2. 客户端应用 librbd 库调用 librados 库，经过 Pool、RBD（RBD 的专属 Pool）、Object、PG、OSDs 进行层层映射之后，得到 Primary OSD 的 IP:Port。
    3. 客户端与 Primary OSD 建立 Socket 通信，将要写入的数据直接传输给 Primary OSD，再由 Primary OSD 同步到 Replica OSDs 中。

    在这里插入图片描述

    RBD QoS

    QoS（Quality of Service，服务质量）起源于网络技术，主要用于解决网络阻塞和延迟问题，能够为指定的网络通信提供更好的服务质量。在存储领域，集群的 IO 能力同样是有限的，比如：带宽，IOPS 等参数。如何避免用户之间争抢资源，保障高优用户的存储服务质量？就需要对有限的 IO 能力进行合理分配，这就是存储 QoS。而 RBD QoS 就是在 Ceph librbd 模块上实现的 QoS。
    在这里插入图片描述
    librbd 架构：

    • librbd 接口层：读取配置，设置配置对象的 Watch 功能
    • Internal：所有 librbd 接口读写的汇聚
    • osdc：对用户数据流进行切片
    • objectcache：用户数据缓冲层
    • send op：数据操作发送层

    RBD QoS 参数选项：

    • conf_rbd_qos_iops_limit 每秒 IO 限制

    • conf_rbd_qos_read_iops_limit 每秒读 IO 限制

    • conf_rbd_qos_write_iops_limit 每秒写 IO 限制

    • conf_rbd_qos_bps_limit 每秒带宽限制

    • conf_rbd_qos_read_bps_limit 每秒读带宽限制

    • conf_rbd_qos_write_bps_limit 每秒写带宽限制

    Token bucket algorithm（令牌桶算法）

    在当前版本（Mimic）中已经实现了基于令牌桶算法的 RBD QoS 功能，但暂时只支持 conf_rbd_qos_iops_limit 选项。

    1. [root@ceph-node2 ~]# rbd create rbd_pool/volume01 --size 10240
    2.  
    3. [root@ceph-node2 ~]# rbd image-meta set rbd_pool/volume01 conf_rbd_qos_iops_limit 1000
    4.  
    5. [root@ceph-node2 ~]# rbd image-meta list rbd_pool/volume01
    6. There is 1 metadatum on this image:
    7.  
    8. Key                     Value
    9. conf_rbd_qos_iops_limit 1000
    10.  
    11. [root@ceph-node2 ~]# rbd image-meta set rbd_pool/volume01 conf_rbd_qos_bps_limit 2048000
    12. failed to set metadata conf_rbd_qos_bps_limit of image : (2) No such file or directory
    13. rbd: setting metadata failed: (2) No such file or directory

    在这里插入图片描述
    在这里插入图片描述

    令牌桶算法的基本思想：

    • 假如用户配置的平均发送速率为 R，则按照 1/R(s) 的速率令牌桶投放令牌；
    • 假设令牌桶最多可以储存 N 个令牌，如果新添的令牌到达时令牌桶已经满了，那么这个令牌被丢弃；
    • 根据预设的匹配规则先对报文进行分类，不符合匹配规则的报文不需要经过令牌桶的处理，直接发送；
    • 反正，符合匹配规则的报文，则需要进行令牌桶处理。当一个 M 字节的数据包到达时，就从令牌桶中取走 M 个令牌，数据包持有令牌运行被发送到网络；
    • 如果令牌桶中少于 M 个令牌，则该数据包不被发送。只有等到桶中投入了新的令牌，报文才可能被发送。这就可以限制报文的流量只能小于或等于令牌投入的速度，以此达到限制流量的目的。

    令牌桶算法的 UML 流程：
    在这里插入图片描述

    • 用户发起的请求异步 IO 到达 Image 中。
    • 请求到达 ImageRequestWQ 队列中。
    • 在 ImageRequestWQ 出队列的时候加入令牌桶算法 TokenBucket。
    • 通过令牌桶算法进行限速，然后发送给 ImageRequest 进行处理。
      在这里插入图片描述

    dmClock algorithm

    当前基于 dmClock 实现的 QoS 还在不断的提交 PR，很多尚未 Merge 到 Master，这里不多做讨论，有待继续跟进社区。

    dmClock 是一种基于时间标签的 I/O 调度算法，最先被 VMware 提出用于集中式管理的存储系统。dmClock 可以将以下实体作为 QoS 对象：

    • RBD Image
    • Pool
    • CephFS Directory
    • Client 或者一组 Client
    • 数据集

    dmClock 主要通过 Reservation、Weight 和 Limit 来实现 QoS 控制：

    • reservation：预留，表示客户端获得的最低 I/O 资源。
    • weight：权重，表示客户端所占共享 I/O 资源的比重。
    • limit：上限，表示客户端可获得的最高 I/O 资源。

    块设备性能测试

    使用 RADOS bench 进行基准测试

    Ceph 提供了一个内置的基准测试程序 RADOS bench，它用于测试 Ceph 对象存储器的性能。
    语法：

    rados bench -p <pool_name> <seconds> <write|seq|rand>
    • -p：指定 Pool
    • Seconds：指定测试运行时长（s）
    • write|seq|rand：指定测试类型，它应该是写、顺序读或者随机读
    • -t：指定井发数，默认为 160
    • –no-cleanup：指定 RODOS bench 写入到 Pool 的临时数据将不被删除，这些数据可用于读操作，默认为删除。

    创建 Test Pool：

    1. [root@ceph-node1 fio_tst]# ceph osd pool create test_pool 8 8
    2. pool 'test_pool' created
    3.  
    4. [root@ceph-node1 fio_tst]# rados lspools
    5. rbd_pool
    6. .rgw.root
    7. default.rgw.control
    8. default.rgw.meta
    9. default.rgw.log
    10. test_pool

    写入性能测试：

    1. [root@ceph-node1 ~]# rados bench -p test_pool 10 write --no-cleanup
    2. hints = 1
    3. Maintaining 16 concurrent writes of 4194304 bytes to objects of size 4194304 for up to 10 seconds or 0 objects
    4. Object prefix: benchmark_data_ceph-node1_34663
    5.   sec Cur ops   started  finished  avg MB/s  cur MB/s last lat(s)  avg lat(s)
    6.     0       0         0         0         0         0           -           0
    7.     1      16        16         0         0         0           -           0
    8.     2      16        19         3   5.99838         6     1.66988     1.45496
    9.     3      16        25         9    11.997        24     2.99072     2.19588
    10.     4      16        32        16    15.996        28     3.33757     2.62036
    11.     5      16        39        23   18.3956        28     2.37105     2.54244
    12.     6      16        45        29   19.3289        24     2.65705     2.53162
    13.     7      16        52        36   20.5669        28     1.10485     2.51232
    14.     8      16        54        38   18.9957         8     3.27297     2.55235
    15.     9      16        67        51   22.6617        52     2.22446     2.57639
    16.    10      15        69        54   21.5954        12     2.41363     2.55092
    17.    11       2        69        67   24.3585        52     2.54614     2.54768
    18. Total time run:         11.0136
    19. Total writes made:      69
    20. Write size:             4194304
    21. Object size:            4194304
    22. Bandwidth (MB/sec):     25.0599
    23. Stddev Bandwidth:       17.0752
    24. Max bandwidth (MB/sec): 52
    25. Min bandwidth (MB/sec): 0
    26. Average IOPS:           6
    27. Stddev IOPS:            4
    28. Max IOPS:               13
    29. Min IOPS:               0
    30. Average Latency(s):     2.52608
    31. Stddev Latency(s):      0.615785
    32. Max latency(s):         4.03768
    33. Min latency(s):         1.00465
    • Average IOPS: 6
    • Bandwidth (MB/sec): 25.0599

    查看写入的临时数据：

    1. [root@ceph-node1 ~]# rados ls -p test_pool
    2. benchmark_data_ceph-node1_34663_object59
    3. benchmark_data_ceph-node1_34663_object42
    4. ...

    测试顺序读性能：

    1. [root@ceph-node1 ~]# rados bench -p test_pool 10 seq
    2. hints = 1
    3.   sec Cur ops   started  finished  avg MB/s  cur MB/s last lat(s)  avg lat(s)
    4.     0       0         0         0         0         0           -           0
    5.     1      16        35        19   75.9741        76    0.323362    0.505157
    6.     2      16        59        43   85.9734        96    0.198388    0.543002
    7.     3      13        69        56    74.645        52     2.17551    0.543934
    8. Total time run:       3.22507
    9. Total reads made:     69
    10. Read size:            4194304
    11. Object size:          4194304
    12. Bandwidth (MB/sec):   85.5795
    13. Average IOPS:         21
    14. Stddev IOPS:          5
    15. Max IOPS:             24
    16. Min IOPS:             13
    17. Average Latency(s):   0.716294
    18. Max latency(s):       2.17551
    19. Min latency(s):       0.136899
    • Average IOPS: 21
    • Bandwidth (MB/sec): 85.5795

    测试随机读性能：

    1. [root@ceph-node1 ~]# rados bench -p test_pool 10 rand
    2. hints = 1
    3.   sec Cur ops   started  finished  avg MB/s  cur MB/s last lat(s)  avg lat(s)
    4.     0       0         0         0         0         0           -           0
    5.     1      16       108        92    367.61       368   0.0316746    0.119223
    6.     2      16       206       190   379.757       392    0.608621    0.145352
    7.     3      16       299       283   377.153       372   0.0378421    0.149943
    8.     4      15       368       353   352.859       280      0.6233    0.167492
    9.     5      16       473       457   365.474       416     0.66508      0.1645
    10.     6      16       563       547   364.547       360  0.00293503    0.166475
    11.     7      16       627       611   349.038       256  0.00289834    0.173168
    12.     8      16       748       732   365.897       484   0.0360462    0.168754
    13.     9      16       825       809   359.457       308  0.00331438    0.171356
    14.    10      16       896       880   351.908       284     0.75437    0.173779
    15. Total time run:       10.3753
    16. Total reads made:     897
    17. Read size:            4194304
    18. Object size:          4194304
    19. Bandwidth (MB/sec):   345.821
    20. Average IOPS:         86
    21. Stddev IOPS:          17
    22. Max IOPS:             121
    23. Min IOPS:             64
    24. Average Latency(s):   0.182936
    25. Max latency(s):       1.06424
    26. Min latency(s):       0.00266894
    • Average IOPS: 86
    • Bandwidth (MB/sec): 345.821

    使用 fio 进行 IO 测试

    fio 是一个第三方 IO 测试工具，在 Linux 系统上使用非常方便。fio 参数解析：

    1. filename=/dev/emcpowerb　支持文件系统或者裸设备，-filename=/dev/sda2 或 -filename=/dev/sdb
    2. direct=1                                 测试过程绕过机器自带的 Buffer，使测试结果更真实
    3. rw=randwread                       测试随机读的 I/O
    4. rw=randwrite                         测试随机写的 I/O
    5. rw=randrw                             测试随机混合写和读的 I/O
    6. rw=read                                 测试顺序读的 I/O
    7. rw=write                                 测试顺序写的 I/O
    8. rw=rw                                     测试顺序混合写和读的 I/O
    9. bs=4k                                     单次 IO 的块文件大小为 4k
    10. bsrange=512-2048                同上，提定数据块的大小范围
    11. size=5g                                  本次的测试文件大小为 5G，以每次 4k 的 IO 进行测试
    12. numjobs=30                           本次的测试线程为 30
    13. runtime=1000                         测试时间为 1000 秒，如果不写则一直将 5G 文件分 4k 每次写完为止
    14. ioengine=psync                      IO 引擎使用 pync 方式，如果要使用 libaio 引擎，需要 yum install libaio-devel 包
    15. rwmixwrite=30                        在混合读写的模式下，写占 30%
    16. group_reporting                      关于显示结果的，汇总每个进程的信息
    17. lockmem=1g                           只使用 1G 内存进行测试
    18. zero_buffers                            用 0 初始化系统 Buffer
    19. nrfiles=8                                  每个进程生成文件的数量

    安装 fio 工具和 librbd 相关开发库（e.g. librbd-devel）：

    $ yum install -y fio "*librbd*"

    创建测试块设备：

    1. root@ceph-node1 ~]# rbd create rbd_pool/volume01 --size 10240
    2.  
    3. [root@ceph-node1 ~]# rbd ls rbd_pool
    4. volume01
    5.  
    6. [root@ceph-node1 ~]# rbd info rbd_pool/volume01
    7. rbd image 'volume01':
    8. 	size 10 GiB in 2560 objects
    9. 	order 22 (4 MiB objects)
    10. 	id: 1229a6b8b4567
    11. 	block_name_prefix: rbd_data.1229a6b8b4567
    12. 	format: 2
    13. 	features: layering
    14. 	op_features:
    15. 	flags:
    16. 	create_timestamp: Thu Apr 25 00:11:20 2019

    编辑测试参数配置：

    1. $ mkdir /root/fio_tst && cd /root/fio_tst
    2.  
    3. $ cat write.fio
    4. [global]
    5. description="write test with block size of 4M"
    6. direct=1
    7. ioengine=rbd
    8. clustername=ceph
    9. clientname=admin
    10. pool=rbd_pool
    11. rbdname=volume01
    12. iodepth=32
    13. runtime=300
    14. rw=randrw
    15. numjobs=1
    16. bs=8k
    17.  
    18. [logging]
    19. write_iops_log=write_iops_log
    20. write_bw_log=write_bw_log
    21. write_lat_log=write_lat_log

    执行 IO 测试：

    1. [root@ceph-node1 fio_tst]# fio write.fio
    2. logging: (g=0): rw=randrw, bs=(R) 8192B-8192B, (W) 8192B-8192B, (T) 8192B-8192B, ioengine=rbd, iodepth=32
    3. fio-3.1
    4. Starting 1 process
    5. Jobs: 1 (f=1): [m(1)][100.0%][r=392KiB/s,w=280KiB/s][r=49,w=35 IOPS][eta 00m:00s]
    6. logging: (groupid=0, jobs=1): err= 0: pid=34842: Thu Apr 25 02:41:25 2019
    7.   Description  : ["write test with block size of 4M"]
    8.    read: IOPS=120, BW=965KiB/s (988kB/s)(283MiB/300063msec)
    9.     slat (nsec): min=734, max=688371, avg=4864.30, stdev=11806.74
    10.     clat (usec): min=771, max=1638.5k, avg=112142.48, stdev=118607.44
    11.      lat (usec): min=773, max=1638.5k, avg=112147.35, stdev=118607.37
    12.     clat percentiles (msec):
    13.      |  1.00th=[    3],  5.00th=[    5], 10.00th=[    7], 20.00th=[   20],
    14.      | 30.00th=[   31], 40.00th=[   48], 50.00th=[   71], 60.00th=[  107],
    15.      | 70.00th=[  144], 80.00th=[  192], 90.00th=[  268], 95.00th=[  342],
    16.      | 99.00th=[  523], 99.50th=[  617], 99.90th=[  827], 99.95th=[  894],
    17.      | 99.99th=[ 1133]
    18.    bw (  KiB/s): min=    4, max=10622, per=41.55%, avg=400.92, stdev=773.36, samples=36196
    19.    iops        : min=    1, max=    1, avg= 1.00, stdev= 0.00, samples=36196
    20.   write: IOPS=120, BW=966KiB/s (990kB/s)(283MiB/300063msec)
    21.     slat (usec): min=2, max=1411, avg=18.63, stdev=31.60
    22.     clat (msec): min=4, max=2301, avg=152.15, stdev=137.61
    23.      lat (msec): min=4, max=2301, avg=152.17, stdev=137.61
    24.     clat percentiles (msec):
    25.      |  1.00th=[   11],  5.00th=[   18], 10.00th=[   24], 20.00th=[   40],
    26.      | 30.00th=[   61], 40.00th=[   86], 50.00th=[  116], 60.00th=[  150],
    27.      | 70.00th=[  192], 80.00th=[  245], 90.00th=[  326], 95.00th=[  405],
    28.      | 99.00th=[  609], 99.50th=[  735], 99.90th=[  961], 99.95th=[ 1133],
    29.      | 99.99th=[ 2198]
    30.    bw (  KiB/s): min=    3, max= 1974, per=14.09%, avg=136.11, stdev=164.08, samples=36248
    31.    iops        : min=    1, max=    1, avg= 1.00, stdev= 0.00, samples=36248
    32.   lat (usec)   : 1000=0.01%
    33.   lat (msec)   : 2=0.39%, 4=1.87%, 10=4.40%, 20=7.39%, 50=19.19%
    34.   lat (msec)   : 100=18.12%, 250=33.10%, 500=13.85%, 750=1.35%, 1000=0.28%
    35.   lat (msec)   : 2000=0.05%, >=2000=0.01%
    36.   cpu          : usr=0.33%, sys=0.12%, ctx=5983, majf=0, minf=30967
    37.   IO depths    : 1=0.6%, 2=1.7%, 4=5.4%, 8=17.9%, 16=68.3%, 32=6.1%, >=64=0.0%
    38.      submit    : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
    39.      complete  : 0=0.0%, 4=95.2%, 8=0.7%, 16=1.3%, 32=2.8%, 64=0.0%, >=64=0.0%
    40.      issued rwt: total=36196,36248,0, short=0,0,0, dropped=0,0,0
    41.      latency   : target=0, window=0, percentile=100.00%, depth=32
    42.  
    43. Run status group 0 (all jobs):
    44.    READ: bw=965KiB/s (988kB/s), 965KiB/s-965KiB/s (988kB/s-988kB/s), io=283MiB (297MB), run=300063-300063msec
    45.   WRITE: bw=966KiB/s (990kB/s), 966KiB/s-966KiB/s (990kB/s-990kB/s), io=283MiB (297MB), run=300063-300063msec
    46.  
    47. Disk stats (read/write):
    48.     dm-0: ios=0/1336, merge=0/0, ticks=0/42239, in_queue=45656, util=1.33%, aggrios=0/1356, aggrmerge=0/87, aggrticks=0/46003, aggrin_queue=46002, aggrutil=1.39%
    49.   sda: ios=0/1356, merge=0/87, ticks=0/46003, in_queue=46002, util=1.39%
    • read: IOPS=120, BW=965KiB/s (988kB/s)(283MiB/300063msec)
    • write: IOPS=120, BW=966KiB/s (990kB/s)(283MiB/300063msec)

    输出结果参数解析：

    1. io        执行了多少（M）IO
    2. bw      平均 IO 带宽
    3. iops    IOPS
    4. runt     线程运行时间
    5. slat     提交延迟
    6. clat     完成延迟
    7. lat       响应时间
    8. cpu     利用率
    9. IO depths     IO 队列
    10. IO submit     单个 IO 提交要提交的 IO 数
    11. IO complete  Like the above submit number, but for completions instead.
    12. IO issued      The number of read/write requests issued, and how many of them were short.
    13. IO latencies   IO 完延迟的分布
    14.  
    15. aggrb        Group 总带宽
    16. minb          最小平均带宽.
    17. maxb         最大平均带宽.
    18. mint           Group 中线程的最短运行时间.
    19. maxt          Group中线程的最长运行时间.
    20. ios              所有Group总共执行的IO数.
    21. merge        总共发生的 IO 合并数.
    22. ticks           Number of ticks we kept the disk busy.
    23. io_queue   花费在队列上的总共时间.
    24. util             磁盘利用率

    对块设备的 IOPS 执行 QoS：

    1. [root@ceph-node1 fio_tst]# rbd image-meta set rbd_pool/volume01 conf_rbd_qos_iops_limit 50
    2. [root@ceph-node1 fio_tst]# rbd image-meta list rbd_pool/volume01
    3. There is 1 metadatum on this image:
    4.  
    5. Key                     Value
    6. conf_rbd_qos_iops_limit 50

    再次执行 IO 测试：

    1. [root@ceph-node1 fio_tst]# fio write.fio
    2. logging: (g=0): rw=randrw, bs=(R) 8192B-8192B, (W) 8192B-8192B, (T) 8192B-8192B, ioengine=rbd, iodepth=32
    3. fio-3.1
    4. Starting 1 process
    5. Jobs: 1 (f=1): [f(1)][100.0%][r=56KiB/s,w=200KiB/s][r=7,w=25 IOPS][eta 00m:00s]
    6. logging: (groupid=0, jobs=1): err= 0: pid=35040: Thu Apr 25 02:50:54 2019
    7.   Description  : ["write test with block size of 4M"]
    8.    read: IOPS=24, BW=199KiB/s (204kB/s)(58.5MiB/300832msec)
    9.     slat (nsec): min=807, max=753733, avg=4863.82, stdev=16831.94
    10.     clat (usec): min=1311, max=1984.2k, avg=482448.41, stdev=481601.17
    11.      lat (usec): min=1313, max=1984.2k, avg=482453.27, stdev=481601.01
    12.     clat percentiles (msec):
    13.      |  1.00th=[    4],  5.00th=[    5], 10.00th=[    6], 20.00th=[    8],
    14.      | 30.00th=[   14], 40.00th=[   23], 50.00th=[   71], 60.00th=[  969],
    15.      | 70.00th=[  978], 80.00th=[  986], 90.00th=[  995], 95.00th=[  995],
    16.      | 99.00th=[ 1003], 99.50th=[ 1011], 99.90th=[ 1036], 99.95th=[ 1938],
    17.      | 99.99th=[ 1989]
    18.    bw (  KiB/s): min=    4, max= 6247, per=100.00%, avg=486.86, stdev=666.26, samples=7483
    19.    iops        : min=    1, max=    1, avg= 1.00, stdev= 0.00, samples=7483
    20.   write: IOPS=25, BW=200KiB/s (205kB/s)(58.8MiB/300832msec)
    21.     slat (usec): min=3, max=1427, avg=19.40, stdev=33.29
    22.     clat (msec): min=6, max=1998, avg=799.32, stdev=501.54
    23.      lat (msec): min=6, max=1998, avg=799.34, stdev=501.54
    24.     clat percentiles (msec):
    25.      |  1.00th=[   13],  5.00th=[   16], 10.00th=[   20], 20.00th=[   34],
    26.      | 30.00th=[  961], 40.00th=[  986], 50.00th=[  995], 60.00th=[  995],
    27.      | 70.00th=[  995], 80.00th=[ 1003], 90.00th=[ 1011], 95.00th=[ 1938],
    28.      | 99.00th=[ 1989], 99.50th=[ 1989], 99.90th=[ 1989], 99.95th=[ 1989],
    29.      | 99.99th=[ 2005]
    30.    bw (  KiB/s): min=    4, max= 1335, per=50.98%, avg=101.96, stdev=184.46, samples=7522
    31.    iops        : min=    1, max=    1, avg= 1.00, stdev= 0.00, samples=7522
    32.   lat (msec)   : 2=0.04%, 4=1.27%, 10=11.24%, 20=11.63%, 50=11.50%
    33.   lat (msec)   : 100=2.03%, 250=0.63%, 500=0.27%, 750=0.34%, 1000=48.66%
    34.   lat (msec)   : 2000=12.41%
    35.   cpu          : usr=0.06%, sys=0.03%, ctx=1118, majf=0, minf=10355
    36.   IO depths    : 1=0.9%, 2=2.7%, 4=7.9%, 8=22.2%, 16=61.5%, 32=4.8%, >=64=0.0%
    37.      submit    : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
    38.      complete  : 0=0.0%, 4=96.0%, 8=0.2%, 16=0.6%, 32=3.1%, 64=0.0%, >=64=0.0%
    39.      issued rwt: total=7483,7522,0, short=0,0,0, dropped=0,0,0
    40.      latency   : target=0, window=0, percentile=100.00%, depth=32
    41.  
    42. Run status group 0 (all jobs):
    43.    READ: bw=199KiB/s (204kB/s), 199KiB/s-199KiB/s (204kB/s-204kB/s), io=58.5MiB (61.3MB), run=300832-300832msec
    44.   WRITE: bw=200KiB/s (205kB/s), 200KiB/s-200KiB/s (205kB/s-205kB/s), io=58.8MiB (61.6MB), run=300832-300832msec
    45.  
    46. Disk stats (read/write):
    47.     dm-0: ios=11/1599, merge=0/0, ticks=68/19331, in_queue=19399, util=0.92%, aggrios=11/1555, aggrmerge=0/46, aggrticks=68/19228, aggrin_queue=19295, aggrutil=0.92%
    48.   sda: ios=11/1555, merge=0/46, ticks=68/19228, in_queue=19295, util=0.92%
    • read: IOPS=24, BW=199KiB/s (204kB/s)(58.5MiB/300832msec)
    • write: IOPS=25, BW=200KiB/s (205kB/s)(58.8MiB/300832msec)

    从结果来看 RBD QoS 的效果是还可以的。

  • 相关阅读:
    【算法刷题-栈与队列篇】
    vue-cropper在ie11下选择本地图片后，无显示、拒绝访问的问题
    网络整体框架介绍
    Qt中的窗口类
    RT-DETR 应用 BiFPN 结构 | 加权双向特征金字塔网络
    固体火箭推进剂理论（一）
    ThinkPHP+基于ThinkPHP的图书馆管理系统 毕业设计-附源码311833
    CodeQL 的安装及基本使用
    设计模式-中介者模式
    嵌入式发展历史
  • 原文地址：https://blog.csdn.net/weixin_43778179/article/details/133866887