ceph（5）--Ceph 与 OpenStack 集成的实现

理解 OpenStack + Ceph 系列文章：

（1）安装和部署

（2）Ceph RBD 接口和工具

（3）Ceph 物理和逻辑结构

（4）Ceph 的基础数据结构

（5）Ceph 与 OpenStack 集成的实现

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

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

（8）关于Ceph PGs

1. Glance 与 Ceph RBD 集成

1.1 代码

Kilo 版本中，glance-store 代码被从 glance 代码中分离出来了，地址在 https://github.com/openstack/glance_store。

Glance 中与 Ceph 相关的配置项：

配置项 含义 默认值
rbd_pool 保存rbd 卷的ceph pool 名称 images
rbd_user rbd user id，仅仅在使用 cephx 认证时使用 none。让 librados 根据 ceph 配置文件决定
rbd_ceph_conf Ceph 配置文件的完整路径 /etc/ceph/ceph.conf
rbd_store_chunk_size 卷会被分成对象的大小（单位为 MB） 64

Glance_store 使用 rbd 和 rados 模块：

import rados

import rbd

Glance_store 中新增了文件 /glance_store/_drivers/rbd.py，其中实现了三个类：

  • class StoreLocation(location.StoreLocation) #表示 Glance image 在 RBD 中的location，格式为 "rbd://<FSID>/<POOL>/<IMAGE>/<SNAP>"
  • class ImageIterator(object) #实现从 RBD image 中读取数据块
  • class Store(driver.Store): #实现将 RBD 作为Nova 镜像后端（backend）

class Store(driver.Store) 实现的主要方法：

（1）获取 image 数据：根据传入的Glance image location，获取 image 的 IO Interator

def get(self, location, offset=0, chunk_size=None, context=None):
    return (ImageIterator(loc.pool, loc.image, loc.snapshot, self), self.get_size(location))
1. 根据 location，定位到 rbd image
2. 调用 image.read 方法，按照 chunk size 读取 image data
3. 将 image data 返回调用端

（2）获取 image 的 size

def get_size(self, location, context=None):
1. 找到 store location：loc = location.store_location
2. 使用 loc 中指定的 pool 或者配置的默认pool
3. 建立 connection 和 打开 IO Context：with rbd.Image(ioctx, loc.image, snapshot=loc.snapshot) as image
4. 获取 image.stat() 并获取 “size”

（3）添加 image

def add(self, image_id, image_file, image_size, context=None):
1. 将 image_id 作为 rbd image name：image_name = str(image_id)
2. 创建 rbd image：librbd.create(ioctx, image_name, size, order, old_format=False, features=rbd.RBD_FEATURE_LAYERING)。如果 rbd 支持 RBD_FEATURE_LAYERING 的话，创建一个 clonable snapshot：rbd://fsid/pool/image/snapshot；否则，创建一个 rbd image：rbd://image
3. 调用 image.write 方法将 image_file 的内容按照 chunksize 依次写入 rbd image
4. 如果要创建 snapshot 的话，调用 image.create_snap(loc.snapshot) 和 image.protect_snap(loc.snapshot) 创建snapshot

（4）删除 image

def delete(self, location, context=None):
1. 根据 location 计算出 rbd image，snapshot 和 pool
2. 如果它是一个 snapshot （location 是 rbd://fsid/pool/image/snapshot），则 unprotect_snap，再 remove_snap，然后删除 image；这时候有可能出错，比如存在基于该 image 的 volume。
3. 如果它不是一个 snapshot （location 是 rbd://image），直接删除 rbd image。这操作也可能会出错。

1.2 使用

（1）使用 Ceph RDB 作为后端存储创建一个 Glance image：

[email protected]:~/s1# glance image-show 71dc76da-774c-411f-a958-1b51816ec50f

+------------------+----------------------------------------------------------------------------------+

| Property         | Value                                                                            |

+------------------+----------------------------------------------------------------------------------+

| checksum         | 56730d3091a764d5f8b38feeef0bfcef                                                 |

| container_format | bare                                                                             |

| created_at       | 2015-09-18T10:22:49Z                                                             |

| direct_url         | rbd://4387471a-ae2b-47c4-b67e-9004860d0fd0/images/71dc76da-774c-                 |

|                        | 411f-a958-1b51816ec50f/snap

可见该Glance image 在 Ceph 中其实是个 RBD snapshot，其父 image 为 rbd://4387471a-ae2b-47c4-b67e-9004860d0fd0/images/71dc76da-774c-411f-a958-1b51816ec50f/，snapshot 名称为 “snap”。

查看 rdb：

[email protected]:~# rbd info images/71dc76da-774c-411f-a958-1b51816ec50f
rbd image ‘71dc76da-774c-411f-a958-1b51816ec50f‘:
size 40162 kB in 5 objects
order 23 (8192 kB objects)
block_name_prefix: rbd_data.103d2246be0e
format: 2
features: layering

Glance 自动创建了它的 snapshot：

[email protected]:~# rbd snap ls images/71dc76da-774c-411f-a958-1b51816ec50f
SNAPID NAME      SIZE
     2 snap  40162 kB

查看该 snapshot：

[email protected]:~# rbd info images/[email protected]
rbd image ‘71dc76da-774c-411f-a958-1b51816ec50f‘:
size 40162 kB in 5 objects
order 23 (8192 kB objects)
block_name_prefix: rbd_data.103d2246be0e
format: 2
features: layering
protected: True

基于该 Glance image 创建的 Cinder volume 都是该 snapshot 的 clone：

[email protected]:~# rbd children images/71dc76da-774c-411f-a958-[email protected]
volumes/volume-65dbaf38-0b9d-4654-bba4-53f12cc906e3
volumes/volume-6868a043-1412-4f6c-917f-bbffb1a8d21a

此时如果试着去删除该 image，则会报错：

The image cannot be deleted because it is in use through the backend store outside of Glance.
这是因为该 image 的 rbd image 的 snapshot 被使用了。

2. Cinder 与 Ceph RBD 的集成

OpenStack Cinder 组件和 Ceph RBD 集成的目的是将 Cinder 卷（volume）保存在 Ceph RBD 中。当使用 Ceph RBD 作为 Cinder 的后端存储时，你不需要单独的一个 Cinder-volume 节点.

2.1 配置项

配置项 含义 默认值
rbd_pool 保存rbd 卷的ceph pool 名称 rbd
rbd_user 访问 RBD 的用户的 ID，仅仅在使用 cephx 认证时使用 none
rbd_ceph_conf Ceph 配置文件的完整路径 ‘’，表示使用 librados 的默认ceph 配置文件
rbd_secret_uuid rbd secret uuid  
rbd_flatten_volume_from_snapshot RBD Snapshot 在底层会快速复制一个元信息表，但不会产生实际的数据拷贝，因此当从 Snapshot 创建新的卷时，用户可能会期望不要依赖原来的 Snapshot，这个选项开启会在创建新卷时对原来的 Snapshot 数据进行拷贝来生成一个不依赖于源 Snapshot 的卷。 false
rbd_max_clone_depth
卷克隆的最大层数，超过的话则使用 fallter。设为 0 的话，则禁止克隆。

与上面这个选项类似的原因，RBD 在支持 Cinder 的部分 API (如从 Snapshot 创建卷和克隆卷)都会使用 rbd clone 操作，但是由于 RBD 目前对于多级卷依赖的 IO 操作不好，多级依赖卷会有比较严重的性能问题。因此这里设置了一个最大克隆值来避免这个问题，一旦超出这个阀值，新的卷会自动被 flatten。

 5
rbd_store_chunk_size 每个 RBD 卷实际上就是由多个对象组成的，因此用户可以指定一个对象的大小来决定对象的数量，默认是 4 MB 4
rados_connect_timeout 连接 ceph 集群的超时时间，单位为秒。如果设为负值，则使用默认 librados 中的值 -1

从这里也能看出来，

（1）Cinder 不支持单个 volume 的条带化参数设置，而只是使用了公共配置项 rbd_store_chunk_size 来指定 order。

（2）Cinder 不支持卷被附加到客户机时设置缓存模式。

2.2 代码

Cinder 使用的就是之前介绍过的 rbd phthon 模块：

import rados
import rbd

它实现了以下主要接口。

2.2.1 与 RBD 的连接

（1）初始化连接到 RBD 的连接

def initialize_connection(self, volume, connector):
hosts, ports = self._get_mon_addrs() #调用 args = [‘ceph‘, ‘mon‘, ‘dump‘, ‘--format=json‘] 获取 monmap，再获取 hosts 和 ports
data = {
            ‘driver_volume_type‘: ‘rbd‘,
            ‘data‘: {
                ‘name‘: ‘%s/%s‘ % (self.configuration.rbd_pool, volume[‘name‘]),
                ‘hosts‘: hosts,
                ‘ports‘: ports,
                ‘auth_enabled‘: (self.configuration.rbd_user is not None),
                ‘auth_username‘: self.configuration.rbd_user,
                ‘secret_type‘: ‘ceph‘,
                ‘secret_uuid‘: self.configuration.rbd_secret_uuid, }
        }

（2）连接到 ceph rados

client = self.rados.Rados(rados_id=self.configuration.rbd_user, conffile=self.configuration.rbd_ceph_conf)
client.connect(timeout= self.configuration.rados_connect_timeout)
ioctx = client.open_ioctx(pool)

（3）断开连接

ioctx.close()
client.shutdown()

2.2.2 创建卷

Cinder API：create_volume

调用的是 RBD 的 create 方法来创建 RBD image：

with RADOSClient(self) as client:
            self.rbd.RBD().create(client.ioctx,
                                  encodeutils.safe_encode(volume[‘name‘]),
                                  size,
                                  order,
                                  old_format=old_format,
                                  features=features)

2.2.3 克隆卷

#创建克隆卷
def create_cloned_volume(self, volume, src_vref): 

# 因为 RBD 的 clone 方法是基于 snapshot 的，所有 cinder 会首先创建一个 snapshot，再创建一个 clone。

 if CONF.rbd_max_clone_depth <= 0: #如果设置的 rbd_max_clone_depth  为负数，则做一个完整的 rbd image copy
     vol.copy(vol.ioctx, dest_name)
depth = self._get_clone_depth(client, src_name) #判断 volume 对应的 image 的 clone depth，如果已经达到 CONF.rbd_max_clone_depth，则需要做 flattern
src_volume = self.rbd.Image(client.ioctx, src_name) #获取 source volume 对应的 rbd image
#如果需要 flattern，
   _pool, parent, snap = self._get_clone_info(src_volume,  src_name) #获取 parent 和 snapshot
   src_volume.flatten() # 将 parent 的data 拷贝到该 clone 中
   parent_volume = self.rbd.Image(client.ioctx, parent) #获取 paraent image
   parent_volume.unprotect_snap(snap) #将 snap 去保护
   parent_volume.remove_snap(snap) #删除 snapshot
src_volume.create_snap(clone_snap) #创建新的 snapshot
src_volume.protect_snap(clone_snap) #将 snapshot 加保护
self.rbd.RBD().clone(client.ioctx, src_name, clone_snap, client.ioctx, dest_name, features=client.features) #在 snapshot 上做clone
self._resize(volume) #如果 clone 的size 和 src volume 的size 不一样，则 resize 

3. Nova 与 Ceph 的集成

常规地，Nova 将虚机的镜像文件放在本地磁盘或者Cinder 卷上。为了与 Ceph 集成，Nova 中添加了新的代码来将镜像文件保存在 Ceph 中。

3.1 Nova 与 Ceph 集成的配置项

配置项 含义 默认值
images_type
其值可以设为下面几个选项中的一个：

  • raw：实现了 class Raw(Image) 类，在 CONF.instances_path 指定的目录中保存 raw 格式的 镜像文件
  • qcow2：实现了 class Qcow2(Image) 类，在 CONF.instances_path 指定的目录中创建和保存 qcow2 格式的镜像文件 [‘qemu-img‘, ‘create‘, ‘-f‘, ‘qcow2‘]
  • lvm：实现了 class Lvm(Image) 类，在 CONF.libvirt.images_volume_group 指定的 LVM Volume Group 中创建 local vm 来存放 vm images
  • rbd：实现了 class Rbd(Image) 类
  • default：使用 use_cow_images 配置项
 default
images_rbd_pool 存放 vm 镜像文件的 RBD pool rbd
images_rbd_ceph_conf Ceph 配置文件的完整路径 ‘’
hw_disk_discard
设置使用或者不使用discard 模式，使用的话需要 Need Libvirt(1.0.6)、 Qemu1.5 (raw format) 和 Qemu1.6(qcow2 format)‘) 的支持

"unmap" : Discard requests("trim" or "unmap") are passed to the filesystem.
"ignore": Discard requests("trim" or "unmap") are ignored and aren‘t passed to the filesystem.

 none
rbd_user rbd user ID  
rbd_secret_uuid rbd secret UUID   

关于 discard 模式（详情见这篇文章）：

Discard，在 SSD 上称为 trim，是在磁盘上回收不使用的数据块的机制。默认地 RBD image 是稀疏的（thin provision），这意味着只有在你写入数据时物理空间才会被占用。在 OpenStack 虚机中使用 discard 机制需要满足两个条件：

（1）虚机使用 Virtio-scsi 作为存储接口，而不是使用传统的 Virtio-blk。这是因为 Virtio-scsi 中实现了如下的新的功能：

  • 设备直接暴露给客户机（device pass-through to directly expose physical storage devices to guests）
  • 更好的性能（better performance and support for true SCSI device）
  • 标准的设备命名方法（common and standard device naming identical to the physical world thus virtualising physical applications is made easier）
  • 更好的扩展性（better scalability of the storage where virtual machines can attach more device (more LUNs etc…)）

要让虚机使用该接口，需要设置 Glance image 的属性：

$ glance image-update --property hw_scsi_model=virtio-scsi --property hw_disk_bus=scsi

（2）在 nova.conf 中配置 hw_disk_discard = unmap

注意目前 cinder 尚不支持 discard。

3.2 Nova 中实现的 RBD image 操作

Nova 在 \nova\virt\libvirt\imagebackend.py 文件中添加了支持 RBD 的新类 class Rbd(Image) 来支持将虚机的image 放在 RBD 中。其主要方法包括：

（1）image create API

def create_image(self, prepare_template, base, size, *args, **kwargs):
# 调用 ‘rbd‘, ‘import‘ 命令将 image file 的数据保存到 rbd image 中

rbd import 命令：

import [–image-format format-id] [–order bits] [–stripe-unit size-in-B/K/M –stripe-count num] [–image-feature feature-name]... [–image-shared] src-path[image-spec]
Creates a new image and imports its data from path (use - for stdin). The import operation will try to create sparse rbd images if possible. For import from stdin, the sparsification unit is the data block size of the destination image (1 << order).
The –stripe-unit and –stripe-count arguments are optional, but must be used together.

虚机创建成功后，在 RBD 中查看创建出来的 image：

[email protected]:~# rbd ls vms
74cbdb41-3789-4eae-b22e-5085de8caba8_disk.local

[email protected]:~# rbd info vms/74cbdb41-3789-4eae-b22e-5085de8caba8_disk.local
rbd image ‘74cbdb41-3789-4eae-b22e-5085de8caba8_disk.local‘:
size 1024 MB in 256 objects
order 22 (4096 kB objects)
block_name_prefix: rbd_data.11552ae8944a
format: 2
features: layering

查看虚机的 xml 定义文件，能看到虚机的系统盘、临时盘和交换盘的镜像文件都在 RBD 中，而且可以使用特定的 cache 模式（由 CONF.libvirt.disk_cachemodes 配置项指定）和 discard 模式（由 CONF.libvirt.hw_disk_discard 配置项设置）：

<devices>
    <disk type="network" device="disk">
      <driver type="raw" cache="writeback" discard="unmap"/>
      <source protocol="rbd" name="vms/74cbdb41-3789-4eae-b22e-5085de8caba8_disk.local">
        <host name="9.115.251.194" port="6789"/>
        <host name="9.115.251.195" port="6789"/>
        <host name="9.115.251.218" port="6789"/>
      </source>
      <auth username="cinder">
        <secret type="ceph" uuid="e21a123a-31f8-425a-86db-7204c33a6161"/>
      </auth>
      <target bus="virtio" dev="vdb"/>
    </disk>
    <disk type="network" device="disk">
      <driver name="qemu" type="raw" cache="writeback"/>
      <source protocol="rbd" name="volumes/volume-6868a043-1412-4f6c-917f-bbffb1a8d21a">
        <host name="9.115.251.194" port="6789"/>
        <host name="9.115.251.195" port="6789"/>
        <host name="9.115.251.218" port="6789"/>
      </source>
      <auth username="cinder">
        <secret type="ceph" uuid="e21a123a-31f8-425a-86db-7204c33a6161"/>
      </auth>
      <target bus="virtio" dev="vda"/>
      <serial>6868a043-1412-4f6c-917f-bbffb1a8d21a</serial>
    </disk>

关于 libvirt.disk_cachemodes 配置项，可以指定镜像文件的缓存模式，其值的格式为 ”A=B"，其中：

  • A 可以为 ‘file‘，‘block‘，‘network‘，‘mount‘。其中，file 是针对 file-backend 的disk（比如使用 qcow2 格式的镜像文件），block 是针对块设备的disk（比如使用 cinder volume 或者 lvm），network 是针对通过网络连接的设备的disk（比如 Ceph）。
  • B 可以为 none,writethrough,writeback,directsync,unsafe。writethrough 和 writeback 可以参考 理解 OpenStack + Ceph （2）：Ceph 的物理和逻辑结构，其它的请自行google。
  • 比如，disk_cachemodes="network=writeback"，disk_cachemodes="block=writeback"。

上面的虚机 XML 定义文件是在Nova 配置为 disk_cachemodes="network=writeback" 和 hw_disk_discard = unmap 的情形下生成的。

（2）image clone API

def clone(self, context, image_id_or_uri):
1. 通过 Glance API 获取 image 的 rbd location
2. 检查 rbd image 是否可以被克隆（检查它是不是在本 ceph cluster 内、是不是 raw 格式、是不是可以访问等）
3. 调用 rbd 的 clone 方法来创建 clone

3.3 镜像 clone 而非下载

使用传统存储作为 image 的后端存储时，在创建虚机的过程中的创建镜像文件时，都是调用  _try_fetch_image_cache 方法来从 Glance 中将镜像文件下载到本地（第一次会缓存，以后就直接读缓存而不用下载），然后再创建镜像文件的方法。而在使用 RBD 作为镜像的后端存储时，如果 Glance 镜像文件被保存在 RBD 中，那么该过程将是重复的（先通过 Glance 从 RDB 中倒出镜像，然后再由 Nova 放到RBD中），而且是非常耗时的。针对这种情况，Nova 实现了一种新的办法，具体见下面的蓝色字体部分：

在 Spawn 虚机过程中，一个步骤是 create image，如下的方法会被调用：

def _create_image(self, context, instance,
                      disk_mapping, suffix=‘‘,
                      disk_images=None, network_info=None,
                      block_device_info=None, files=None,
                      admin_pass=None, inject_files=True,
                      fallback_from_host=None):

      if not booted_from_volume: #如果不是从 volume 启动虚机
            root_fname = imagecache.get_cache_fname(disk_images, ‘image_id‘)
            size = instance.root_gb * units.Gi
            backend = image(‘disk‘)
            if backend.SUPPORTS_CLONE: #如果 image backend 支持 clone 的话（目前的各种 image backend，只有 RBD 支持 clone）
                def clone_fallback_to_fetch(*args, **kwargs):
                        backend.clone(context, disk_images[‘image_id‘]) #直接调用 backend 的 clone 函数做 image clone
                fetch_func = clone_fallback_to_fetch
            else:
                fetch_func = libvirt_utils.fetch_image #否则走常规的 image 下载-导入过程
            self._try_fetch_image_cache(backend, fetch_func, context, root_fname, disk_images[‘image_id‘], instance, size, fallback_from_host)

可见，当 nova 后端使用 ceph 时，nova driver 调用 RBD imagebackend 命令，直接在 ceph 存储层完成镜像拷贝动作（无需消耗太多的nova性能，也无需将镜像下载到hypervisor本地，再上传镜像到ceph），如此创建虚拟机时间将会大大提升。当然，这个的前提是 image 也是保存在 ceph 中，而且 image 的格式为 raw，否则 clone 过程会报错。 具体过程如下：

（1）这是 Glance image 对应的 rbd image：

[email protected]:~# rbd info images/0a64fa67-3e34-42e7-b7b0-423c11850e18
rbd image ‘0a64fa67-3e34-42e7-b7b0-423c11850e18‘:
        size 564 MB in 71 objects
        order 23 (8192 kB objects)
        block_name_prefix: rbd_data.16d21e1d755b
        format: 2
        features: layering

（2）使用该 image 创建第一个虚机

[email protected]:~# rbd info vms/982b8eac-6bcc-4a21-bd04-b67e26188be0_disk
rbd image ‘982b8eac-6bcc-4a21-bd04-b67e26188be0_disk‘:
        size 3072 MB in 384 objects
        order 23 (8192 kB objects)
        block_name_prefix: rbd_data.130a36a6b435
        format: 2
        features: layering
        parent: images/0a64fa67-3e34-42e7-b7b0-[email protected]
        overlap: 564 MB

[email protected]:~# rbd info vms/982b8eac-6bcc-4a21-bd04-b67e26188be0_disk.local
rbd image ‘982b8eac-6bcc-4a21-bd04-b67e26188be0_disk.local‘:
        size 2048 MB in 512 objects
        order 22 (4096 kB objects)
        block_name_prefix: rbd_data.a69b2ae8944a
        format: 2
        features: layering

[email protected]:~# rbd info vms/982b8eac-6bcc-4a21-bd04-b67e26188be0_disk.swap
rbd image ‘982b8eac-6bcc-4a21-bd04-b67e26188be0_disk.swap‘:
        size 102400 kB in 25 objects
        order 22 (4096 kB objects)
        block_name_prefix: rbd_data.a69e74b0dc51
        format: 2
        features: layering

（3）创建第二个虚机

[email protected]:~# rbd info vms/a9670d9a-8aa7-49ba-baf5-9d7a450172f3_disk
rbd image ‘a9670d9a-8aa7-49ba-baf5-9d7a450172f3_disk‘:
        size 3072 MB in 384 objects
        order 23 (8192 kB objects)
        block_name_prefix: rbd_data.13611f6abac6
        format: 2
        features: layering
        parent: images/0a64fa67-3e34-42e7-b7b0-[email protected]
        overlap: 564 MB

（4）会看到 Glance image 对应的 RBD image 有两个克隆，分别是上面虚机的系统盘

[email protected]:~# rbd children  images/0a64fa67-3e34-42e7-b7b0-[email protected]
vms/982b8eac-6bcc-4a21-bd04-b67e26188be0_disk
vms/a9670d9a-8aa7-49ba-baf5-9d7a450172f3_disk

4. 其它集成

除了上面所描述的 Cinder、Nova 和 Glance 与 Ceph RBD 的集成外，OpenStack 和 Ceph 之间还有其它的集成点：

（1）使用 Ceph 替代 Swift 作为对象存储 （网络上有很多比较 Ceph 和 Swift 的文章，比如 1,2,3,）

（2）CephFS 作为 Manila 的后端（backend）

（3）Keystone 和  Ceph Object Gateway 的集成，具体可以参考文章 （1）（2）

参考文档：

http://www.sebastien-han.fr/blog/2015/02/02/openstack-and-ceph-rbd-discard/

http://www.sebastien-han.fr/blog/2013/11/26/back-from-icehouse-openstack-summit-ceph-slash-openstack-integration/

http://www.wzxue.com/openstack-cinder-advance/

原文地址：https://www.cnblogs.com/treasure716/p/9668732.html

时间： 2024-10-30 04:53:09

ceph（5）--Ceph 与 OpenStack 集成的实现的相关文章

Ceph块设备管理与Openstack配置（上）

Oepnstack之CEPH系列是根据Ceph Cookbook整理的笔记,分为以下几个部分: <Ceph简介> <Ceph集群操作> <Ceph块设备管理与Openstack配置> <深入Ceph> <ceph优化与性能测试> 注意:此文对应ceph版本为10.1.2 #ceph -v ceph version 10.1.2(4a2a6f72640d6b74a3bbd92798bb913ed380dcd4) 前言 目前接触到的Mitaka版本O

Ceph存储系统(ceph安装，inkscope安装)--未完

Ceph存储系统 概述 ceph是一个Linux PB级别的分布式存储系统,ceph的目标简单地定义为: 可轻松扩展到PB容量 对多种工作负载的高性能(每秒输入/输出操作[IOPS]和带宽) 高可靠性 与常见的集中式存储不同,分布式存储技术并不是将数据存储在某个或多个特定的节点上,而是通过网络使用多台机器上的磁盘空间,并将这些分散的存储资源构成一个虚拟的存储设备,数据分散地存储在这些机器的各个磁盘上 ceph架构 ceph架构大概可以划分为四部分:客户端(数据用户).元数据服务器(缓存和同步分布

ceph 安装ceph问题汇总

1.在不同节点安装ceph时,出现以下异常: 参考这里 ceph deploy RuntimeError: NoSectionError: No section: 'ceph' 解决方法: 在报错的机器上尝试: yum remove ceph-release rm /etc/yum.repos.d/ceph.repo.rpmsave 执行以后再执行 ceph-deploy install admin node1 node2 node3 2.ceph用户没有权限 **执行激活osd盘时出现 **

OpenStack集成Docker

声明:绝对原创,欢迎转载,但请标明出处,谢谢! 最近在做openstack与Docker的集成工作,走了不少弯路,遇到不少问题,不过最终搭建成功了.现在将过程分享出来,以供参考. 一.环境介绍 1.软件环境: CentOs7 64位.OpenStack(Juno).Docker version 1.5.0 2.网络: 1 $vim /etc/hosts 2 3 192.168.245.148 compute1 4 5 192.168.245.141 controller 3.安装前提: 3.1

openstack 集成vmware 填坑经验

liberty 以后版本不在支持直连esxi,只支持链接vcenter 记得在esxi防火墙上启用vnc 默认vcenter是https,要么配证书,要么在nova.conf 改insecure=true 要么改源码 oslo_vmware/service.py 里面有关于ssl链接的东东注释掉,后两者我试过了都ok

理解 OpenStack + Ceph （5）：OpenStack 与 Ceph 之间的集成 [OpenStack Integration with Ceph]

理解 OpenStack + Ceph 系列文章: (1)安装和部署 (2)Ceph RBD 接口和工具 (3)Ceph 物理和逻辑结构 (4)Ceph 基础数据结构 (5)Ceph 与 OpenStack 的集成 1. Glance 与 Ceph RBD 集成 1.1 代码 Kilo 版本中,glance-store 代码被从 glance 代码中分离出来了,地址在 https://github.com/openstack/glance_store. Glance 中与 Ceph 相关的配置项

Openstack+KVM+Ceph+Docker 集成云计算中

对于以基础架构即服务形式部署和设计云计算产品的公司而言,数据复制和存储机制仍然是确保为客户提供完整性和服务连续性的实际前提条件.云计算提供了一种模型,其中数据的位置没有其他基础架构模型中那么重要(比如在一些模型中,公司直接拥有昂贵的存储硬件).Ceph 是一个开源.统一.分布式的存储系统,提供了一种便捷方式来部署包含商用硬件.低成本且可大规模扩展的存储平台.了解如何创建一个 Ceph 集群(从单一点实现对象.块和文件存储).Ceph 的算法和复制机制,以及如何将它与您的云数据架构和模型相集成.作

OpenStack+Ceph平台集成

文档下载 OpenStack+Ceph平台构建(已排好版) 参考文档 官方文档 OpenStack集成Ceph 如何将Ceph与OpenStack集成 部署步骤 Ceph配置 创建Pool # ceph osd pool create volumes 64 # ceph osd pool create images 64 # ceph osd pool create vms 64 OpenStack配置 安装Ceph Client包 在glance-api(控制节点)节点上 yum instal

高可用OpenStack（Queen版）集群-15.Glance&amp;Cinder集成Ceph

参考文档: Install-guide:https://docs.openstack.org/install-guide/ OpenStack High Availability Guide:https://docs.openstack.org/ha-guide/index.html 理解Pacemaker:http://www.cnblogs.com/sammyliu/p/5025362.html Ceph: http://docs.ceph.com/docs/master/start/int