理解 OpenStack + Ceph （3）：Ceph RBD 接口和工具 [Ceph RBD API and Tools]

时间 2019-11-12

标签理解 openstack ceph rbd 接口工具 api tools 繁體版

原文原文链接

本系列文章会深刻研究 Ceph 以及 Ceph 和 OpenStack 的集成：html

（1）安装和部署python

（2）Ceph RBD 接口和工具linux

（3）Ceph 物理和逻辑结构git

（4）Ceph 的基础数据结构github

（5）Ceph 与 OpenStack 集成的实现编程

（6）QEMU-KVM 和 Ceph RBD 的缓存机制总结ubuntu

（7）Ceph 的基本操做和常见故障排除方法centos

（8）关于Ceph PGsapi

Ceph 做为一个统一的分布式存储，其一大特点是提供了丰富的编程接口。咱们来看看下面这张经典的图：缓存

其中，librados 是 Ceph 的基础接口，其它的接口好比 RADOSGW, RBD 和 CephFS 都是基于 librados 实现的。本文试着分析下 Ceph 的各类接口库和经常使用的工具。

1 librados

1.1 librados 概述

Ceph 提供一个消息层协议（messaging layer protocol）使得 ceph 客户端能够和 Ceph Monitor 以及 Ceph OSD Daemon 交互。librados 就是一个该协议的编码库形式的实现。全部的 Ceph clients 要么使用 librados 要么使用其封装的更高层 API 与对象存储进行交互。好比，librbd 使用 librados 提供 Ceph 客户端与 RBD 交互 API。

librados 是使用 C++ 实现的。它实现了 Ceph 的一个私有协议，使得客户端能够直接、同步或者异步、并行地和 MON 和 OSD 服务通讯，来执行以下操做：

Pool Operations
Snapshots
Read/Write Objects
Create or Remove
Entire Object or Byte Range
Append or Truncate
Create/Set/Get/Remove XATTRs
Create/Set/Get/Remove Key/Value Pairs
Compound operations and dual-ack semantics

librados 于 OSD 交互的示例：

同时也提供 C, python，Java 和 PHD 语言的绑定。使用它以前，你须要安装它：

安装 C/C++ 版本的 librados，好比在 Ubuntu 环境中，运行 sudo apt-get install librados-dev，而后你就会在 /usr/include/rados 目录中找到C/C++的头文件。
使用 Python 版本的 librados，好比在 Ubuntu 环境中，运行 sudo apt-get install python-rados。具体请见 1.1.2 部分。

一个 Ceph client 经过 librados 存放或者读取数据块到 Ceph 中，须要通过如下步骤：

Client 调用 librados 链接到 Ceph monitor，获取 Cluster map。
当 client 要读或者写数据时，它建立一个与 pool 的 I/O Context。该 pool 关联有 ruleset，它定义了数据在 Ceph 存储集群中是怎么存放的。
client 经过 I/O Context 提供 object name 给 librados，它使用该 object name 和 cluster map 计算出 PG 和 OSD 来定位到数据的位置。
client 直接和 OSD Deamon 交互来读或者写数据。

可见，第一步中，ceph client 须要知道 Ceph Minotor 的访问方法，以及用户的身份信息，而这些信息每每是放在 ceph 配置文件中，好比：

[global]
mon host = 192.168.1.1
keyring = /etc/ceph/ceph.client.admin.keyring

1.2 librados for phthon

Python rados 模块是 librados 的 Python 的很薄的封装，它在 github 上的源文件在 /src/pybind/rados.py, 安装到 Ubunt 后的源文件在 /usr/lib/python2.7/dist-packages/rados.py。

（1）要使用 rados.py 模块，在你的代码中 import rados

（2）建立一个 cluster handler，你须要提供 ceph.conf 文件和 keystring

import rados, sys

#Create Handle Examples. 你有多种方式来指定 ceph.conf
（1）cluster = rados.Rados(conffile='ceph.conf') #默认路径的 ceph.conf
（2）cluster = rados.Rados(conffile=sys.argv[1]) #指定路径的 ceph.conf
（3）cluster = rados.Rados(conffile = 'ceph.conf', conf = dict (keyring = '/path/to/keyring')) #默认路径的 ceph.conf 和指定的 keystring

（3）链接到 ceph cluster

cluster.connect()

（4）获取 ceph cluster 的信息，以及操做 pool

cluster_stats = cluster.get_cluster_stats()
pools = cluster.list_pools()
cluster.create_pool('test')
cluster.delete_pool('test')

（5）向 ceph 集群读写数据，须要有一个 I/O Context （ioctx）

ioctx = cluster.open_ioctx('data')

（6）而后就能够读写数据了

ioctx.write_full("hw", "Hello World!") #向 “hw” object 写入 "Hello World!"
print ioctx.read("hw") #读取 ”hw“ object 的数据
ioctx.remove_object("hw") #删除 “hw” object

更多的信息，能够参考 LIBRADOS (PYTHON)。

2. librbd：Go 语言实现的访问 Ceph RBD 的接口

RBD 是 Rados Block Device 的缩写，而 librbd 是访问 RBD 的库。它调用 librados C 语言绑定，以及与Linux 内核中的 rbd 模块通讯，来提供 RMD image 的建立、删除、映射和删除映射等操做。其中，建立和删除等操做是调用 librados，而将 RDB Image 映射到主机上则是调用 Linux rbd 内核模块：

// MapDevice maps an image to a device on the host. Returns the device path and
// any errors. On error, the device path will be blank.
func (img *Image) MapDevice() (string, error)

librbd 的源代码在 https://github.com/contiv/librbd，是使用 Go 语言实现的，调用 librados 的 C 库以及linux 内核模块，在 Ubuntu 14 上它的文件在 /usr/lib/x86_64-linux-gnu/librbd.so.1。它支持：

Open a connection to the rbd pool
Creates an image called test (Removing it before if necessary)
Maps it to a block device on the local host
Creates a snapshot of the image, called test-snap.
Lists and prints the snapshots available.

3. rbd.py：librbd 的 python 封装

rbd python 模块 rbd.py 的源代码在 https://github.com/ceph/ceph/blob/master/src/pybind/rbd.py，它是 librbd 的一个 python 封装。

def load_librbd():
    """
    Load the librbd shared library.
    """
    librbd_path = find_library('rbd')
    if librbd_path:
        return CDLL(librbd_path)

    # try harder, find_library() doesn't search LD_LIBRARY_PATH
    # in addition, it doesn't seem work on centos 6.4 (see e46d2ca067b5)
    try:
        return CDLL('librbd.so.1')
    except OSError as e:
        raise EnvironmentError("Unable to load librbd: %s" % e)

它只封装了 librbd 中的同步操做。它主要提供了 RBD、Image 和 SnapIterator 三个类。在 Ubuntu 上，安装 python-rbd 包就能够在你的机器上找到该文件：/usr/lib/python2.7/dist-packages/rbd.py。提供相似文件访问的方式去访问 ceph RBD image （链接-打开-使用-关闭）。该模块除了提供主要三个类 Rados, Ioctx, 和Image （Rados 对应于 ceph 集群；Ioctx 对应于 pool；Image 对应于 RBD Image）之外，还封装了 librdb 的返回值做为 Error 类。rbd 模块还提供 Error 类的具体的子类，好比 PermissionError 和 IOError。

3.1 基本流程

#使用 rbd 以前，链接到 RADOS，并打开一个 IO context （和特定 pool 相关）
cluster = rados.Rados(conffile='my_ceph.conf')
cluster.connect()
ioctx = cluster.open_ioctx('mypool')

#初始化一个 RBD 对象
rbd_inst = rbd.RBD()
size = 4 * 1024**3  # 4 GiB
#建立 image
rbd_inst.create(ioctx, 'myimage', size)

#初始化 image 对象
image = rbd.Image(ioctx, 'myimage')
#准备 600 个字符的数据
data = 'foo' * 200
#写入数据
image.write(data, 0)

#关闭 image 对象
image.close()
#关闭 IO Context
ioctx.close()
#关闭链接
cluster.shutdown()

更优化的编码方式：

with rados.Rados(conffile='my_ceph.conf') as cluster:
    with cluster.open_ioctx('mypool') as ioctx:
        rbd_inst = rbd.RBD()
        size = 4 * 1024**3  # 4 GiB
        rbd_inst.create(ioctx, 'myimage', size)
        with rbd.Image(ioctx, 'myimage') as image:
            data = 'foo' * 200
            image.write(data, 0)

3.2 class `rbd.RBD` `类`

class rbd. RBD 该类封装了 librbd 的 CURD 操做，包括：

create(ioctx, name, size, order=None, old_format=True, features=0, stripe_unit=0, stripe_count=0)：建立一个 RBD Image
list(ioctx) 返回 RBD Image 的名称列表
clone(p_ioctx, p_name, p_snapname, c_ioctx, c_name, features=0, order=None)：克隆 Image 的snapshot 到一个 COW 克隆
- features (int) – bitmask of features to enable; if set, must include layering
- order (int) – the image is split into (2**order) byte objects

remove(ioctx, name) ：删除一个 RBD image。这可能会须要较长的时间，由于它须要等待组成该 image 的每一个对象都被删除。
rename(ioctx, src, dest)：修改 RBD Image 的名称

3.3 class `rbd.Image`

该类的一个实例表明一个 RBD image。它的方法用于对 image 的 I/O 操做和处理其 snapshot。它的主要方法包括：

class rbd.Image(ioctx, name, snapshot=None, read_only=False)
copy(dest_ioctx, dest_name) Copy the image to another location.

create_snap(name) Create a snapshot of the image
flatten() Flatten clone image (copy all blocks from parent to child)
list_snaps() Iterate over the snapshots of an image
protect_snap(name) Mark a snapshot as protected. This means it can’t be deleted until it is unprotected.
read(offset, length, fadvise_flags=0) Read data from the image.
remove_snap(name) Delete a snapshot of the image
resize(size) Change the size of the image
rollback_to_snap(name) Revert the image to its contents at a snapshot.
set_snap(name) Set the snapshot to read from. Writes will raise ReadOnlyImage while a snapshot is set. Pass None to unset the snapshot (reads come from the current image) , and allow writing again.
size() Get the size of the image in bytes
stat() Get information about the image.
unprotect_snap(name) Mark a snapshot unprotected. This allows it to be deleted if it was protected.
write(data, offset, fadvise_flags=0) Write data to the image.
parent_info Get information about a cloned image’s parent (if any)

4. Ceph RBD 对 Linux 主机和虚机的支持，以及 Linux RBD 内核模块

使用 Ceph 的块存储有两种路径：

一种是利用QEMU走librbd路径，主要为虚拟机提供块存储设备
另外一种是使用 kernel module，走 kernel 的路径，主要为Host提供块设备支持。

两种途径的接口实现不彻底相同。就目前来讲，前者是目前更稳定的途径，也是Ceph全部应用场景中最普遍使用的。网上多篇文章认为目前内核模块尚不稳定，建议尽可能不要使用。

4.1 qemu-kvm 使用librbd 访问 RBD

QEMU 经过 librbd 库访问 RBD，而 librbd 是调用 librados。

QEMU 对 librbd 的调用关系可使用 ldd 命令查看：

root@compute1:~# ldd /usr/bin/qemu-system-x86_64 | grep rbd
        librbd.so.1 => /usr/lib/x86_64-linux-gnu/librbd.so.1 (0x00007f76ef9e8000)

qemu-img 命令支持直接建立 rbd 镜像，好比：

qemu-img create -f rbd rbd:vmimages/ubuntu-newdrive 2G

而后可使用 virsh 将它定义为一个 device，下面是 device.xml 文件：

<disk type='network' device='disk'>
  <driver name='qemu' type='raw'/>
  <auth username='vmimages'>
    <secret type='ceph' uuid='76e3a541-b997-58ac-f7bd-77dd7d4347cb'/>
  </auth>
  <source protocol='rbd' name='vmimages/ubuntu-newdrive'>
    <host name='192.168.0.100' port='6789'/>
  </source>
  <target dev='vdc' bus='virtio'/>
</disk>

而后该 device 添加到虚机中便可。虚机访问 RBD 设备是经过：

咱们知道，Linux Kernel 中的块设备驱动是 virtio_blk，它会对虚机的块设备各类请求封装成一个消息经过 virtio 框架提供的队列发送到 QEMU 的 IO 线程，QEMU 收到请求后会转给相应的 QEMU Block Driver 来完成请求，当使用 RDB 时 QEMU block driver 会调用 librbd 来访问 Ceph RDB 设备。

4.2 使用内核模块，将 RBD 设备映射给主机

rbd 工具也能够调用 Linux RBD 内核模块来将 RBD Image 挂载到Linux 主机上做为一个新的设备。一开始，该内核模块并无被加载，可是在执行了 rbd map 操做后，libceph 模块自动被加载：

root@compute2:~# lsmod | grep rbd #此时，rbd 内核模块尚未被加载

root@compute2:~# rbd -n client.cinder map vms/smb01_d1 #作 rbd map 操做
/dev/rbd1
root@compute2:~# lsmod | grep rbd #此时， rbd 内核模块已经被自动加载
rbd 63787 1
libceph 225461 1 rbd
root@compute2:~# rmmod rbd #这时候，rbd 内核模块也没法被卸载
rmmod: ERROR: Module rbd is in use

在看 rbd 的帮助，咱们要能够看到 map，unmap，showmapped 命令确实调用的是 rbd 内核模块：

map <image-name>                            map image to a block device using the kernel
unmap <device>                              unmap a rbd device that was mapped by the kernel
showmapped                                  show the rbd images mapped by the kernel

过程：

#建立一个 RDB Image
root@compute1:~# rbd -n client.cinder create vms/smb01_d2 --size 1000 --image-format 2

#将 Image map 给主机  
root@compute1:~# rbd -n client.cinder map vms/smb01_d2 /dev/rbd2

#列表已经被映射的 RDB Image
root@compute1:~# rbd showmapped
id pool image    snap device
1  vms  smb01_d1 -    /dev/rbd1
2  vms  smb01_d2 -    /dev/rbd2
3  vms  smb01_d3 -    /dev/rbd3
#unmap
root@compute1:~# rbd unmap /dev/rbd1
root@compute1:~# rbd unmap /dev/rbd2
root@compute1:~# rbd unmap /dev/rbd3

其实，rbd 是和 /sys/bus/rbd 交互来完成map：

access("/sys/bus/rbd", F_OK)            = 0
socket(PF_NETLINK, SOCK_RAW|SOCK_CLOEXEC|SOCK_NONBLOCK, 15) = 3
setsockopt(3, SOL_SOCKET, SO_ATTACH_FILTER, "\r\0\0\0\0\0\0\0\3000b\261\375\177\0\0", 16) = 0
bind(3, {sa_family=AF_NETLINK, pid=0, groups=00000002}, 12) = 0
getsockname(3, {sa_family=AF_NETLINK, pid=6958, groups=00000002}, [12]) = 0
setsockopt(3, SOL_SOCKET, SO_PASSCRED, [1], 4) = 0
open("/sys/bus/rbd/add_single_major", O_WRONLY) = -1 ENOENT (No such file or directory)
open("/sys/bus/rbd/add", O_WRONLY)      = 4
write(4, "9.115.251.194:6789,9.115.251.195:6789,9.115.251.218:6789 nam"..., 101) = 101
close(4)

你甚至能够直接对 /sys/bus/rbd 操做来 map，showmapped 和 unmap RBD Image：

root@compute1:~#echo "10.20.30.40  name=admin rbd foo" | sudo tee /sys/bus/rbd/add #map

root@compute1:~# ls /sys/bus/rbd/devices                                           #showmapped 1
root@compute1:~# echo 1 | sudo tee /sys/bus/rbd/remove                             #unmap 1
root@compute1:~# ls /sys/bus/rbd/devices

相信能够参考 RBD KERNEL OBJECT OPERATIONS 和这篇文章。

5. rbd 命令行

Ceph 提供 rbd 做为一个操做 ceph rados 块设备（RBD）image 的工具，根据调用的底层模块，其功能可分为两部分：

常规的 create, list, introspect 和 remove block device images，以及 clone images, create snapshots, rollback an image to a snapshot, view a snapshot 等操做，是经过调用 librados 来实现的。其调用层次为 rbd -> librbd -> librados：

root@compute1:~# which rbd
/usr/bin/rbd
root@compute1:~# ldd /usr/bin/rbd | grep rbd
        librbd.so.1 => /usr/lib/x86_64-linux-gnu/librbd.so.1 (0x00007fcf7ae62000)
root@compute1:~# ldd /usr/lib/x86_64-linux-gnu/librbd.so.1 | grep rados
        librados.so.2 => /usr/lib/x86_64-linux-gnu/librados.so.2 (0x00007f29b543f000)

将 RBD image map 给 Linux 主机，以及从 Linux 主机 unmap等操做，是经过和 Linux rbd 内核模块通讯来实现的。详情请参考 1.4.2 部分。

在 Ubuntu 上，你安装了 ceph-common 就能够获得该工具，其命令行格式为：

rbd [ -c ceph.conf ] [ -m monaddr ] [ -p | –pool pool ] [ –size size ] [ –order bits ] [ command ... ]

部分使用示例：

在 pool ‘mypool’ 中建立 100 GB 的 rbd image ‘myimage’: rbd create mypool/myimage --size 102400
在默认的 ‘rbd’ pool 中建立 image：rbd create myimage --size 102400
建立对象大小为 8MB 的 image：rbd create mypool/myimage --size 102400 --order 23

这里的 order 参数比较特别，它和 ceph 的对象条带化有关。ceph 客户端的一个数据块，会被条带化成多个小的对象，被保存在 Ceph 分布式对象存储（RADOS）中。这样的话，对 image 的读和写操做能够被分散到集群的多个节点上，一般来说这样能够防止某个 image 很是大或者很是忙时单个节点称为性能瓶颈。

Ceph 的条带化行为受三个参数控制：

order：被条带化的对象的大小为 2^[order] bytes。默认的 oder 为 22，这时候对象大小为4MB。
stripe_unit：每一个 [stripe_unit]的连续字节会被相连的保存到同一个对象中，直到去写下一个对象
stripe_count：在写入了 [stripe_unit] 字节到 [stripe_unit]各对象后，ceph 又从新从第一个对象开始写下一个条带，直到该对象达到了它的最大size。这时候，ceph 转移到下 [stripe_unit] 个对象。

默认的时候，[stripe_unit] 等于 object size；stripe_count 为1. 要设置其余的 [ stripe_unit] 值，须要Ceph v0.53 版本及之后版本对 STRIPINGV2 的支持以及使用 format 2 image 格式。

删除 image：rbd rm mypool/myimage
建立 snapshot：rbd snap create mypool/myimage@mysnap
建立 clone：rbd clone mypool/myimage@mysnap otherpool/cloneimage
查看snapshot 的全部 clone：rbd children mypool/myimage@mysnap
删除 snapshot：rbd snap rm mypool/myimage@mysnap
将 image map 到 linux 主机：rbd map mypool/myimage
将 image 从主机上删除（unmap）：rbd unmap /dev/rbd0

6. 总结一下各模块的关系（以 OpenStack 的计算节点为例）

参考连接：

http://www.wzxue.com/rbdcache/

https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-bus-rbd

http://docs.ceph.com/docs/master/rbd/rbd/