Ceph 客户端和 Ceph OSD 都使用 CRUSH map 和 CRUSH 算法。

具有多个对象副本或 M 擦除编码块有助于防止数据丢失，但它不足以解决高可用性问题。通过反映 Ceph Storage 集群的底层物理组织，libvirt 可以建模，从而解决了关联设备故障的地址潜在的资源。通过将集群的拓扑编码到集群映射中，CRUSH 放置策略可在不同的故障域间分离对象副本或纠删代码区块，同时仍维护所需的伪随机分布。例如，为解决并发故障的可能性，可能最好确保数据副本或纠删代码区块在不同的 shelves、机架、电源、控制器或物理位置上的设备上。这有助于防止数据丢失并允许集群以降级状态运行。

Ceph 可以支持多个层次结构，将一种类型的硬件性能配置集与其他类型的硬件性能配置集分开。例如，虽然 CRUSH 可以为硬盘创建一个层次结构，为 SSD 创建另一个层次结构。使用性能域 （考虑到底层硬件的性能特性的分级结构）变得非常流行 ，因此通常会需要满足不同的性能要求。在操作上，它们只是具有多个 根 类型 bucket 的 CRUSH map。用例示例包括：

CRUSH 映射支持 设备类别 的概念。Ceph 可以发现存储设备的各个方面，并且自动分配类，如 hdd、ssd 或 nvme。但是，虽然 CRUSH 不仅限于这些默认值。例如，可以使用 CRUSH 层次结构来分隔不同类型的工作负载。例如，SSD 可以用于日志或直写日志，bucket 索引或原始对象存储。CRUSH 可支持不同的设备类别，如 sd -bucket-index 或 ssd-object-storage，因此 Ceph 无法将相同的存储介质用于不同的工作负载，因此性能更加可预测且一致。

在 scenes 后面，Ceph 为每个设备类生成一个 crush root。这些根应仅通过在 OSD 中设置或更改设备类来修改。您可以使用以下命令查看生成的 roots：

[ceph: root@host01 /]# ceph osd crush tree --show-shadow
ID   CLASS  WEIGHT    TYPE NAME
-24    ssd   4.54849  root default~ssd
-19    ssd   0.90970      host ceph01~ssd
  8    ssd   0.90970          osd.8
-20    ssd   0.90970      host ceph02~ssd
  7    ssd   0.90970          osd.7
-21    ssd   0.90970      host ceph03~ssd
  3    ssd   0.90970          osd.3
-22    ssd   0.90970      host ceph04~ssd
  5    ssd   0.90970          osd.5
-23    ssd   0.90970      host ceph05~ssd
  6    ssd   0.90970          osd.6
 -2    hdd  50.94173  root default~hdd
 -4    hdd   7.27739      host ceph01~hdd
 10    hdd   7.27739          osd.10
-12    hdd  14.55478      host ceph02~hdd
  0    hdd   7.27739          osd.0
 12    hdd   7.27739          osd.12
 -6    hdd  14.55478      host ceph03~hdd
  4    hdd   7.27739          osd.4
 11    hdd   7.27739          osd.11
-10    hdd   7.27739      host ceph04~hdd
  1    hdd   7.27739          osd.1
 -8    hdd   7.27739      host ceph05~hdd
  2    hdd   7.27739          osd.2
 -1         55.49022  root default
 -3          8.18709      host ceph01
 10    hdd   7.27739          osd.10
  8    ssd   0.90970          osd.8
-11         15.46448      host ceph02
  0    hdd   7.27739          osd.0
 12    hdd   7.27739          osd.12
  7    ssd   0.90970          osd.7
 -5         15.46448      host ceph03
  4    hdd   7.27739          osd.4
 11    hdd   7.27739          osd.11
  3    ssd   0.90970          osd.3
 -9          8.18709      host ceph04
  1    hdd   7.27739          osd.1
  5    ssd   0.90970          osd.5
 -7          8.18709      host ceph05
  2    hdd   7.27739          osd.2
  6    ssd   0.90970          osd.6

要创建性能域，请使用设备类和单一 CRUSH 层次结构。在此特定操作中不需要手动编辑 CRUSH map。只需将 OSD 添加到 CRUSH 层次结构中，然后执行以下操作：

CRUSH 位置是 OSD 在 CRUSH map 的层次结构中的位置。在命令行界面中表达 CRUSH 位置时，即 CRUSH 位置指定符采用描述 OSD 位置的 name/value 对列表。例如，如果 OSD 位于特定行、机架、机箱和主机中，并且是默认 CRUSH 树的一部分，则其 crush 位置可以描述如下：

root=default row=a rack=a2 chassis=a2a host=a2a1

备注：

要将存储桶实例添加到 CRUSH 层次结构中，请指定存储桶名称及其类型。bucket 名称在 CRUSH map 中必须是唯一的。

ceph osd crush add-bucket {name} {type}

添加层次结构所需的每个 bucket 类型的实例。以下示例演示了为一行添加含有对象存储的 SSD 主机和一架主机：

ceph osd crush add-bucket ssd-row1 row
ceph osd crush add-bucket ssd-row1-rack1 rack
ceph osd crush add-bucket ssd-row1-rack1-host1 host
ceph osd crush add-bucket ssd-row1-rack1-host2 host
ceph osd crush add-bucket hdd-row1 row
ceph osd crush add-bucket hdd-row1-rack2 rack
ceph osd crush add-bucket hdd-row1-rack1-host1 host
ceph osd crush add-bucket hdd-row1-rack1-host2 host
ceph osd crush add-bucket hdd-row1-rack1-host3 host
ceph osd crush add-bucket hdd-row1-rack1-host4 host

完成这些步骤后，查看您的树。

ceph osd tree

请注意，层次结构保持扁平。在将存储桶添加到 CRUSH map 后，您必须将存储桶移到层次结构中。

在创建初始集群时，Ceph 具有默认的 CRUSH map，其根存储桶为 default，您的初始 OSD 主机会显示在 默认 存储桶下。将存储桶实例添加到 CRUSH map 时，它将显示在 CRUSH 层次结构中，但它不一定出现在特定的 bucket 中。

要将存储桶实例移到 CRUSH 层次结构中的特定位置，请指定存储桶名称及其类型。例如：

ceph osd crush move ssd-row1 root=ssd-root
ceph osd crush move ssd-row1-rack1 row=ssd-row1
ceph osd crush move ssd-row1-rack1-host1 rack=ssd-row1-rack1
ceph osd crush move ssd-row1-rack1-host2 rack=ssd-row1-rack1

完成这些步骤后，您可以查看您的树。

ceph osd tree

要从 CRUSH 层次结构中移除存储桶实例，请指定存储桶名称。例如：

ceph osd crush remove {bucket-name}

或者：

ceph osd crush rm {bucket-name}

如果您要删除更高级别的存储桶（例如，一个 root 用户（如 default）），请检查池是否使用了选择该 bucket 的 CRUSH 规则。如果是这样，您需要修改 CRUSH 规则，否则对等规则会失败。

使用 Ceph CLI 创建存储桶时，Ceph 默认将算法设置为 straw2。Ceph 支持四个存储桶算法，各自代表性能和重组织效率之间的利弊。如果您不确定要使用的存储桶类型，我们建议使用 straw2 存储桶。bucket 算法有：

ceph osd crush tree 命令在树视图中打印 CRUSH bucket 和项目。使用此命令来确定特定 bucket 中的 OSD 列表。它将打印与 ceph osd tree 类似的输出。

要返回附加详情，请执行以下操作：

# ceph osd crush tree -f json-pretty

该命令会返回类似如下的输出：

[
    {
        "id": -2,
        "name": "ssd",
        "type": "root",
        "type_id": 10,
        "items": [
            {
                "id": -6,
                "name": "dell-per630-11-ssd",
                "type": "host",
                "type_id": 1,
                "items": [
                    {
                        "id": 6,
                        "name": "osd.6",
                        "type": "osd",
                        "type_id": 0,
                        "crush_weight": 0.099991,
                        "depth": 2
                    }
                ]
            },
            {
                "id": -7,
                "name": "dell-per630-12-ssd",
                "type": "host",
                "type_id": 1,
                "items": [
                    {
                        "id": 7,
                        "name": "osd.7",
                        "type": "osd",
                        "type_id": 0,
                        "crush_weight": 0.099991,
                        "depth": 2
                    }
                ]
            },
            {
                "id": -8,
                "name": "dell-per630-13-ssd",
                "type": "host",
                "type_id": 1,
                "items": [
                    {
                        "id": 8,
                        "name": "osd.8",
                        "type": "osd",
                        "type_id": 0,
                        "crush_weight": 0.099991,
                        "depth": 2
                    }
                ]
            }
        ]
    },
    {
        "id": -1,
        "name": "default",
        "type": "root",
        "type_id": 10,
        "items": [
            {
                "id": -3,
                "name": "dell-per630-11",
                "type": "host",
                "type_id": 1,
                "items": [
                    {
                        "id": 0,
                        "name": "osd.0",
                        "type": "osd",
                        "type_id": 0,
                        "crush_weight": 0.449997,
                        "depth": 2
                    },
                    {
                        "id": 3,
                        "name": "osd.3",
                        "type": "osd",
                        "type_id": 0,
                        "crush_weight": 0.289993,
                        "depth": 2
                    }
                ]
            },
            {
                "id": -4,
                "name": "dell-per630-12",
                "type": "host",
                "type_id": 1,
                "items": [
                    {
                        "id": 1,
                        "name": "osd.1",
                        "type": "osd",
                        "type_id": 0,
                        "crush_weight": 0.449997,
                        "depth": 2
                    },
                    {
                        "id": 4,
                        "name": "osd.4",
                        "type": "osd",
                        "type_id": 0,
                        "crush_weight": 0.289993,
                        "depth": 2
                    }
                ]
            },
            {
                "id": -5,
                "name": "dell-per630-13",
                "type": "host",
                "type_id": 1,
                "items": [
                    {
                        "id": 2,
                        "name": "osd.2",
                        "type": "osd",
                        "type_id": 0,
                        "crush_weight": 0.449997,
                        "depth": 2
                    },
                    {
                        "id": 5,
                        "name": "osd.5",
                        "type": "osd",
                        "type_id": 0,
                        "crush_weight": 0.289993,
                        "depth": 2
                    }
                ]
            }
        ]
    }
]

在可以启动一个 OSD（为 up 和 in）且 Ceph 为 OSD 分配放置组前，将一个 Ceph OSD 添加到 CRUSH 层次结构中是最终的步骤。

Red Hat Ceph Storage 5 及更新的版本使用 Ceph 编排器在 CRUSH 层次结构中部署 OSD。有关更多信息，请参阅在所有可用设备上部署 Ceph OSD。

若要手动添加 OSD，您必须先准备 Ceph OSD，然后才能将其添加到 CRUSH 层次结构中。例如，在单一节点上创建 Ceph OSD：

ceph orch daemon add osd {host}:{device},[{device}]

CRUSH 层次结构不重要，因此 ceph osd crush add 命令允许您根据需要将 OSD 添加到 CRUSH 层次结构中。您指定的位置应反映其实际位置。如果您至少指定了一个存储桶，命令会将 OSD 放入您指定的最具体的存储桶中，并 将它移到您指定的任何其他 bucket 下。

将 OSD 添加到 CRUSH 层次结构中：

ceph osd crush add {id-or-name} {weight}  [{bucket-type}={bucket-name} ...]

以下示例将 osd.0 添加到层次结构中：

ceph osd crush add osd.0 1.0 root=default datacenter=dc1 room=room1 row=foo rack=bar host=foo-bar-1

对于 Red Hat Ceph Storage 5 及更新的版本，您可以使用 Ceph 编排器为主机设置初始 CRUSH 位置。如需更多信息，请参阅设置主机的初始 CRUSH 位置。

要替换 OSD，请参阅使用 Ceph 编排器替换 OSD

如果存储集群拓扑更改，您可以手动移动 CRUSH 层次结构中的 OSD，以反映其实际位置。

要在 CRUSH 层次结构中移动 OSD：

ceph osd crush set {id-or-name} {weight} root={pool-name}  [{bucket-type}={bucket-name} ...]

从 CRUSH 层次结构中移除 OSD 是您要从集群中移除 OSD 的第一步。从 CRUSH map 移除 OSD 时，OSD 会重新计算哪些 OSD 相应获取放置组和数据重新平衡。如需了解更多详细信息，请参阅添加/删除 OSD。

对于 Red Hat Ceph Storage 5 及更新的版本，您可以使用 Ceph 编排器从存储集群中移除 OSD。有关更多信息，请参阅使用 Ceph 编排器删除 OSD 守护进程。

要从正在运行的集群的 CRUSH map 中手动删除 OSD，请执行以下操作：

ceph osd crush remove {name}

要为 OSD 设置设备类，请执行以下操作：

# ceph osd crush set-device-class <class> <osdId> [<osdId>...]

例如：

# ceph osd crush set-device-class hdd osd.0 osd.1
# ceph osd crush set-device-class ssd osd.2 osd.3
# ceph osd crush set-device-class bucket-index osd.4

要为 OSD 删除设备类，请执行以下操作：

# ceph osd crush rm-device-class <class> <osdId> [<osdId>...]

例如：

# ceph osd crush rm-device-class hdd osd.0 osd.1
# ceph osd crush rm-device-class ssd osd.2 osd.3
# ceph osd crush rm-device-class bucket-index osd.4

要为使用该类的所有 OSD 重命名设备类，请执行以下操作：

# ceph osd crush class rename <oldName> <newName>

例如：

# ceph osd crush class rename hdd sas15k

要列出 CRUSH 映射中的设备类，请执行以下操作：

# ceph osd crush class ls

输出将类似如下：

[
    "hdd",
    "ssd",
    "bucket-index"
]

要列出属于特定类的所有 OSD，请执行以下操作：

# ceph osd crush class ls-osd <class>

例如：

# ceph osd crush class ls-osd hdd

输出是一个 OSD 号列表。例如：

0
1
2
3
4
5
6

要列出引用同一类的所有 crush 规则，请执行以下操作：

# ceph osd crush rule ls-by-class <class>

例如：

# ceph osd crush rule ls-by-class hdd

要在 CRUSH 映射中的 Terabytes 中设置 OSD CRUSH 权重，请执行以下命令

ceph osd crush reweight {name} {weight}

其中：

在创建 OSD 时使用此设置，或者在添加 OSD 后立即调整 CRUSH 权重。它通常不会更改 OSD 生命周期。

使用 ceph osd crush reweight 可能非常耗时。您可以通过执行以下内容来设置（或重置）存储桶下的所有 Ceph OSD 权重（row、rack 和 node 等）：

osd crush reweight-subtree <name>

其中,

name 是 CRUSH bucket 的名称。

对于 ceph osd in 和 ceph osd out，一个 OSD 为 in 集群，或 out 集群。这是 monitor 如何记录 OSD 的状态。但是，尽管一个 OSD 为 in 集群，它可能遇到了一个故障情况，在出现这种情况下，您不应该完全依赖它，直到相关的问题被解决（例如，替换存储驱动器、更改控制器等）。

您可以通过执行以下操作为为一个特定的 OSD 增加或减少 in 权重（无需改变它在 Terabytes 中的权重）：

ceph osd reweight {id} {weight}

其中：

CRUSH 旨在为写入请求分配新数据对象 PG 和 PG 到 OSD 的写入请求提供统一的概率分布。但是，集群可能会变得没有平衡。这可能会因多种原因而发生。例如：

您可以通过执行以下命令来重新加权 OSD：

ceph osd reweight-by-utilization [threshold]  [weight_change_amount] [number_of_OSDs] [--no-increasing]

例如：

ceph osd test-reweight-by-utilization 110 .5 4 --no-increasing

其中：

执行这个命令或其他权重命令会覆盖由这个命令分配的权重（例如，osd reweight-by-utilization, osd crush weight, osd weight, in 或 out）。

在 CRUSH 层次结构的 OSD 中，一些 OSD 有可能获得比其他 OSD 更多的 PG，从而导致负载更高。您可以通过执行以下操作来重新由 PG 分发来重新加权 OSD 以解决这种情况：

osd reweight-by-pg <poolname>

其中：

CRUSH 树 bucket 应该是其leaf weight 的总和。如果手动编辑 CRUSH map 权重，您应该执行以下内容，以确保 CRUSH bucket 树准确反映 bucket 下的叶 OSD 的总和。

osd crush reweight-all

要从命令行列出 CRUSH 规则，请执行以下操作：

ceph osd crush rule list
ceph osd crush rule ls

要转储特定 CRUSH 规则的内容，请执行以下操作：

ceph osd crush rule dump {name}

要添加 CRUSH 规则，您必须指定规则名称、要使用的层次结构的根节点、您要复制到的存储桶类型（例如："rack'、'row' 等等），以及选择存储桶的模式。

ceph osd crush rule create-simple {rulename} {root} {bucket-type} {firstn|indep}

Ceph 将创建具有您指定的 类型选择leaf 和 1 存储桶的规则。

例如：

ceph osd crush rule create-simple deleteme default host firstn

创建以下规则：

{ "id": 1,
  "rule_name": "deleteme",
  "type": 1,
  "min_size": 1,
  "max_size": 10,
  "steps": [
        { "op": "take",
          "item": -1,
          "item_name": "default"},
        { "op": "chooseleaf_firstn",
          "num": 0,
          "type": "host"},
        { "op": "emit"}]}

要为复制池创建 CRUSH 规则，请执行以下操作：

# ceph osd crush rule create-replicated <name> <root> <failure-domain> <class>

其中：

例如：

# ceph osd crush rule create-replicated fast default host ssd

要添加与纠删代码池一起使用的 CRUSH 规则，您可以指定规则名称和纠删代码 profile。

ceph osd crush rule create-erasure {rulename} {profilename}

要删除规则，请执行以下内容并指定 CRUSH 规则名称：

ceph osd crush rule rm {name}

在调优 CRUSH 之前，您应该确保所有 Ceph 客户端和所有 Ceph 守护进程都使用相同的版本。如果您最近已升级，请确保您已重启守护进程并重新连接客户端。

调整 CRUSH 可调项的最简单方法是通过更改到已知配置文件。这些是：

您可以使用以下命令在正在运行的集群中选择配置集：

# ceph osd crush tunables <profile>

通常，您应该在升级后设置 CRUSH 可调项，或者收到警告。从 v0.74 开始，如果 CRUSH 可调项没有设置为其最佳值，Ceph 将发出一个健康警告，其最佳值为 v0.73。要进行这个警告，有两个选项：

如果确保所有客户端都在运行最新的代码，可以通过提取 CRUSH 映射、修改值并将其注入集群中来调整可调项。

为了方便参考，可以使用以下内容设置 CRUSH 可调项的旧值：

crushtool -i /tmp/crush --set-choose-local-tries 2 --set-choose-local-fallback-tries 5 --set-choose-total-tries 19 --set-chooseleaf-descend-once 0 --set-chooseleaf-vary-r 0 -o /tmp/crush.legacy

同样，需要特殊的 --enable-unsafe-tunables 选项。如上所述，请在恢复到旧值后小心运行 ceph-osd 守护进程的旧版本，因为功能位不完全强制实施。

要获取集群的 CRUSH 映射，请执行以下操作：

ceph osd getcrushmap -o {compiled-crushmap-filename}

Ceph 将输出(-o)编译的 CRUSH map 到您指定的文件名。由于 CRUSH 映射采用编译的形式，因此您必须先将其解译，然后才能编辑它。

要解译 CRUSH 映射，请执行以下操作：

crushtool -d {compiled-crushmap-filename} -o {decompiled-crushmap-filename}

Ceph 会将已编译的 CRUSH map 和输出(-o)替换为您指定的文件名。

要编译 CRUSH 映射，请执行以下操作：

crushtool -c {decompiled-crush-map-filename} -o {compiled-crush-map-filename}

Ceph 将已编译的 CRUSH map 存储到您指定的文件名。

要为集群设置 CRUSH 映射，请执行以下操作：

ceph osd setcrushmap -i  {compiled-crushmap-filename}

Ceph 将输入您指定为群集 CRUSH map 的文件名的已编译 CRUSH map。

Ceph 可以通过防止永久丢失数据获得好处。但是，在 OSD 失败后，永久数据丢失的风险会增加，直到其数据被完全恢复为止。仍然有可能造成持久性数据丢失。以下场景描述了如何在带有三个数据副本的单个放置组中永久丢失数据：

硬件故障不是例外，而是预计中的情况。要防止持续的场景，理想的恢复过程应该尽可能快。集群的大小、您的硬件配置和放置组的数量在总恢复时扮演重要角色。

Ceph 可能会在 9 个剩余的 OSD 间随机存储剩余的 150 个放置组。因此，每个剩余的 OSD 可能会向所有其他 OSD 发送副本，并接收一些新的对象，因为剩余的 OSD 现在已负责分配给它们的一些 150 个放置组。

总恢复时间取决于支持池的硬件。例如，在一个 10 个 OSD 集群中，如果一个主机包含一个带有 1 TB SSD 的 OSD，且 10 GB/s 交换机连接每个 10 个主机，则恢复时间将花费 M 分钟。相反，如果主机包含两个 SATA OSD，1 GB/s 交换机连接五个主机，恢复将大大延长。值得注意的是，在这种大小的集群中，放置组的数量对数据持久性几乎没有影响。放置组计数可以是 128 或 8192，恢复不能慢或更快。

但是，相同的 Ceph 集群增加到 20 个 OSD，而不是 10 个 OSD 才可以加快恢复速度，因而能显著提高数据持久性。这是因为什么？每个 OSD 现在只参与 75 个放置组，而不是 150 个。20 个 OSD 集群仍然需要所有剩余的 19 个 OSD 执行相同副本操作，以便恢复。在 10 个 OSD 集群中，每个 OSD 必须复制大约 100 GB。在 20 个 OSD 集群中，每个 OSD 必须分别复制 50 GB。如果网络瓶颈是瓶颈，恢复将尽快发生两次。换句话说，随着 OSD 数量增加，恢复时间会减少。

在上述 10 个 OSD 集群中，如果任何 OSD 失败，则大约有 8 个放置组（即 75 pgs / 9 osds 被恢复）将只有一个 Surviving 副本。如果其中任何 8 个剩余的 OSD 失败，则一个放置组的最后对象可能会丢失（即 8 pgs / 8 osds，只有一个剩余副本被恢复）。这是为什么首选从一些大型集群开始（例如 50 个 OSD）。

当集群的大小增加到 20 个 OSD 时，OSD 丢失的放置组数量会损坏。第二个 OSD 大约会降级 2（即 35 pgs / 19 osds 被恢复）而不是 8，而第三个 OSD 仅在含有存活副本的两个 OSD 之一时丢失数据。换句话说，如果在恢复时间范围内丢失一个 OSD 的概率为 0.0001%，它在 10 个 OSD 的集群中为 8 * 0.0001%，在 20 个 OSD 的集群中为 2 * 0.0001%。对于数据持久性，具有 512 或 4096 个放置组的集群中大致相当于有 50 个 OSD。

将 OSD 添加到集群时，可能需要很长时间才能为新的 OSD 填充放置组和对象。但是，任何对象都没有降级，而添加 OSD 不会影响数据持久性。

Ceph 寻求避免热点 - 即，一些 OSD 显著提高了超过其他 OSD 的流量。理想情况下，CRUSH 将对象分配到放置组，以便在放置组被分配给 OSD（也可以随机）时，主 OSD 存储对象会均匀分布在群集和热点上，以及因为数据分发而造成的网络超额订阅问题。

由于 CRUSH 计算每个对象的放置组，但实际上不知道该放置组中各个 OSD 中存储的数据量，因此 放置组数量和 OSD 数量之间的比率可能会大大影响数据的分布。

例如，如果三个副本池中只有一个放置组具有十个 OSD，Ceph 将仅使用三个 OSD 来存储数据，因为 CRUSH 不会有其他选择。当更多放置组可用时，CRUSH 更有可能在 OSD 之间均匀分布对象。CRUSH 也均匀地分配放置组到 OSD。

只要存在一两个数量级的放置组数量超过 OSD，分布就应该是如此。例如，3 个 OSD 256 个放置组，10 个 OSD 512 或 1024 个放置组，以此类推。

OSD 和放置组之间的比率通常解决了在实施对象条带化的 Ceph 客户端的数据分发问题。例如，4TB 块设备可能会分片为 4 MB 对象。

OSD 和放置组之间的比率无法处理其他情形中的数据分布不均匀，因为 CRUSH 不会将对象大小纳入考量。使用 librados 接口存储一些相对较小的对象，有些非常大的对象可能会导致数据分布不均匀。例如，一百万 4K 对象以 4 GB 的总数均匀分布在 10 个 OSD 上的 1000 个放置组中。它们将在每个 OSD 上使用 4 GB / 10 = 400 MB。如果一个 400 MB 对象添加到池中，为放置了该对象的放置组提供支持的三个 OSD 将会填充 400 MB + 400 MB = 800 MB，而其他七个 OSD 仍然仅被占据 400 MB。

对于每个放置组，OSD 和 Ceph 监视器会一直需要内存、网络和 CPU，在恢复期间甚至更多。由集群放置组中的集群对象共享这个开销是放置组存在的主要原因之一。

尽量减少放置组的数量可以节省大量资源。

PG 计算器计算您和地址特定用例的放置组数量。当使用 Ceph 客户端（如 Ceph 对象网关）时，PG 计算器尤其有用，其中有许多池通常使用相同的规则（CRUSH 层次结构）。您仍然可以参照 PG Count for Small Clusters 和 Calculating PG Count 来手动计算 PG。但是，PG 计算器是计算 PG 的首选方法。

有关详细信息，请参阅红帽客户门户网站 上 每个池计算器的 Ceph 放置组(PG)。

当您创建池时，您还要为池创建几个放置组。如果您没有指定放置组数量，Ceph 将使用默认值 8，这不可接受。您可以为池增加放置组数量，但我们建议 Ceph 配置文件中设置合理的默认值。

osd pool default pg num = 100
osd pool default pgp num = 100

您需要设置放置组数量（总计）以及用于对象的放置组数量（在 PG 分隔中使用的数量）。它们应该相等。

小集群不会从大量放置组中受益。随着 OSD 数量的增加，为 pg_num 和 pgp_num 选择正确的值会变得更为重要，因为在出现问题时以及数据不稳定（这是严重事件导致数据丢失的可能性）时，对集群的行为有显著影响。使用带有小集群的 PG 计算器 非常重要。

如果您有超过 50 个 OSD，建议每个 OSD 大约有 50-100 个放置组来均衡资源使用情况、数据持久性和分布。如果您有超过 50 个 OSD，在 Small 集群的 PG Count 中选择是理想的选择。对于单个对象池，您可以使用以下公式获取基准：

                (OSDs * 100)
   Total PGs =  ------------
                 pool size

其中，pool size 是复制池的副本数，或用于删除代码池的 K+M 总和（ceph osd erasure-code-profile 的返回值）。

然后，您应该检查结果是否适合您设计 Ceph 集群以最大化数据持久性、数据分布和最小化资源使用量。

结果应 向上取整为两个最接近的电源。向上舍入是可选的，但建议使用 CRUSH 在放置组之间均匀地平衡对象数量。

对于 200 个 OSD 和池大小 3 个副本的集群，您可以估计 PG 数量，如下所示：

   (200 * 100)
   ----------- = 6667. Nearest power of 2: 8192
        3

在 200 个 OSD 之间分布 8192 个放置组，评估每个 OSD 大约有 41 个放置组。您还需要考虑集群中可能会使用的池数量，因为每个池也会创建放置组。确保您有合理的 最大 PG 数量。

当使用多个数据池来存储对象时，您需要确保平衡每个池的放置组数量与每个 OSD 的放置组数量，以便您可以达到合理的放置组总数。目的是在不消耗系统资源或使 peering 进程太慢的情况下，为每个 OSD 达到合理的差异。

在由 10 个池组成的 exemplary Ceph Storage 集群中，每个池在 10 个 OSD 上有 512 个放置组，总计有 5120 个 PG 分布于 10 个 OSD 中，或每个 OSD 都有 512 个放置组。取决于硬件配置，可能无法使用过多的资源。相反，如果您创建 1,000 个池，每个 PG 具有 512 个 PG，OSD 将处理 ~50,000的放置组，这需要大量资源。使用每个 OSD 的放置组数量太多的操作可能会显著降低性能，特别是重新平衡或恢复期间。

Ceph Storage 集群为每个 OSD 有一个默认值 300 个放置组。您可以在 Ceph 配置文件中设置不同的最大值。

mon pg warn max per osd

Red Hat Ceph Storage 集群中的每个池都有一个 pg_autoscale_mode 属性，而 PG 的 PG 可以设置为 off、上的、或 warn。

自动缩放器使用 bulk 标志来确定哪个池应当以完整补充的 PG 开头，并且仅在池之间的使用量比率不会被缩减。但是，如果池没有 bulk 标记，池以最少的 PG 开头，并且仅在池中有更多使用量时才会开始。

您可以查看池，它的相对利用率以及存储集群中 PG 数量的建议更改。

SIZE 是池中存储的数据量。

如果存在 TARGET SIZE，则管理员指定的数据量是管理员最终在此池中存储的数据量。系统在计算时会使用这两个值中的较大的值。

RATE 是决定池使用的原始存储容量的池的倍数。例如，一个 3 副本池的比率为 3.0，而 k=4,m=2 纠删代码池的比例为 1.5。

RAW CAPACITY 是 OSD 上原始存储容量的总量，它们负责存储池的数据。

RATIO 是池消耗的总容量的比例，即 ratio = 大小，即 * 速率/原始容量。

TARGET RATIO （如果存在）是管理员指定的存储比率，是与带有目标比率的其他池相对应的期望池的消耗。如果同时指定了目标大小字节和比例，则比率将具有优先权。TARGET RATIO 的默认值为 0， 除非在创建池时指定。您向池中提供的 --target_ratio 越大，您希望池具有的大量 PG。

EFFECTIVE RATIO 是在以两种方式调整后的目标比率：1。减少设定目标大小的池预期使用容量。2. 在带有目标比率设置的池之间规范化目标比率，以便它们一起处理剩余空间。例如，目标 ratio 1.0 的 4 池具有 0.25 的有效比例。系统使用的较大的实际比率，以及计算的有效比率。

BIAS 被视为一个倍数，根据之前有关特定池应有的 PG 量的信息，手动调整池的 PG。默认情况下，如果 1.0，否则值（除非在创建池时已指定）。您提供的池中提供的 --bias 越多，您希望池拥有的 PG 大。

PG_NUM 是池的当前 PG 数量，或者当 pg_num 更改正在进行时，池工作的 PG 数量的当前 PG 数量。NEW PG_NUM （若存在）是建议的 PG 数量(pg_num)。它始终是 2 的指数，它只有在建议的值与因当前值的不同大于 3 倍时才存在。

AUTOSCALE，是池 pg_autoscale_mode，可以为 on, off, 或 warn。

BULK 用于确定哪个池应以 PG 的完整补充开头。BULK 仅在使用量在池中的使用比率不平衡时进行缩减。如果池没有此标志，池以最少的 PG 开始，且仅在池中有更多使用量时才使用。

BULK 的值为 true, false, 1, 或 0, 其中 1 等同于 true，0 等同于 false。默认值为 false。

BULK 值可以在池创建过程中或之后设置 。

有关使用 bulk 标记的更多信息，请参阅 创建池 和设置放置组自动扩展模式。

允许集群根据集群使用量自动扩展 PG，是扩展 PG 的最简单方法。Red Hat Ceph Storage 使用整个系统的可用存储和 PG 的目标数量，比较每个池中存储的数据数量，并相应地应用 PG。该命令仅更改其当前 PG 数 (pg_num) 大于计算出的或建议的 PG 数的 3 倍的池。

每个 OSD 的目标 PG 数量基于 mon_target_pg_per_osd 可配置。默认值为 100。

ceph osd pool create --pg-num-min NUMBER
ceph osd pool create --pg-num-max NUMBER

ceph osd pool create --pg-num-min 50
ceph osd pool create --pg-num-max 150

如果要同时为所有池启用或禁用自动扩展器，您可以使用 noautoscale 全局标志。当某些 OSD 被退回或集群处于维护状态时，这个全局标志很有用。您可以在任何活动前设置标志，并在活动完成后取消设置它。

默认情况下，noautoscale 标志设置为 off。当设置这个标记时，所有池 都为 off，并且所有池都禁用自动扩展器。

新创建的池消耗少量集群容量，并出现在需要少量的 PG 的系统中。然而，在大多数情形中，集群管理员知道哪些池预期消耗了大多数系统容量。如果提供此信息，称为 Red Hat Ceph Storage 的目标大小，此类池可以从头开始使用更合适的 PG 数(pg_num)。此方法可防止 pg_num 中的后续更改，并在进行这些调整时与移动数据相关的开销。

您可以使用以下方法指定池 的目标大小 ：

要在池中设置放置组数量，您必须在创建池时指定放置组数量。详情请查看创建池。为池设置放置组后，您可以增加或减少放置组数量。要更改放置组数量，请使用以下命令：

ceph osd pool set POOL_NAME pg_num PG_NUMBER

[ceph: root@host01 /]# ceph osd pool set pool1 pg_num 60
set pool 2 pg_num to 60

增加或减少放置组数量后，还必须在集群重新平衡前调整放置的放置组数量(pgp_num)。pgp_num 应当等于 pg_num。

ceph osd pool set POOL_NAME pgp_num PGP_NUMBER

[ceph: root@host01 /]# ceph osd pool set pool1 pgp_num 60
set pool 2 pgp_num to 60

获取池中的放置组数量：

ceph osd pool get POOL_NAME pg_num

[ceph: root@host01 /]# ceph osd pool get pool1 pg_num
pg_num: 60

获取放置组的统计信息：

ceph pg dump [--format FORMAT]

有效格式为 plain （默认）和 json。

获取所有放置组的统计信息处于指定状态：

ceph pg dump_stuck {inactive|unclean|stale|undersized|degraded [inactive|unclean|stale|undersized|degraded...]} INTEGER

Inactive 放置组无法处理读取或写入，因为它们正在等待具有最新数据最多的 OSD 上线并在内。

Unclean 放置组包含没有复制所需时间的对象。它们应该是恢复。

过时的 放置组处于未知状态 - 托管它们尚未报告给 monitor 集群的 OSD（配置为 mon_osd_report_timeout）。

有效格式为 plain （默认）和 json。阈值定义了放置组在返回统计之前卡住的最小秒数（默认为 300 秒）。

获取特定放置组的放置组映射：

ceph pg map PG_ID

[ceph: root@host01 /]# ceph pg map 1.6c
osdmap e13 pg 1.6c (1.6c) -> up [1,0] acting [1,0]

Ceph 返回放置组映射、放置组和 OSD 状态。

检索特定放置组的统计信息：

ceph pg PG_ID query

清理放置组：

ceph pg scrub PG_ID

Ceph 检查主节点和任何副本节点，生成放置组中所有对象的目录，并比较它们以确保没有对象丢失或不匹配，并且其内容一致。假设副本都匹配，最终语义 sweep 可确保所有与快照相关的对象元数据一致。通过日志报告错误。

如果集群丢失了一个或多个对象，并且您决定取消搜索丢失数据，您必须将未找到的对象标记为 lost。

如果查询了所有可能的位置，并且对象仍然丢失，您可能需要放弃丢失的对象。这有不常的故障组合，允许集群了解在进行写入本身恢复之前执行的写入操作。

Ceph 仅支持"revert"选项，该选项可回滚到对象的各种版本，或者如果它是新对象，则可以忘记它。要将 "unfound" 对象标记为 "lost"，请使用以下命令：

ceph pg PG_ID mark_unfound_lost revert|delete

要创建新的纠删代码 profile，请执行以下操作：

ceph osd erasure-code-profile set <name> \
         [<directory=directory>] \
         [<plugin=plugin>] \
         [<stripe_unit=stripe_unit>] \
         [<crush-device-class>]\
         [<crush-failure-domain>]\
         [<key=value> ...] \
         [--force]

其中：

删除纠删代码 profile：

ceph osd erasure-code-profile rm <name>

如果配置集由池引用，则删除操作将失败。

显示纠删代码池配置集：

ceph osd erasure-code-profile get <name>

列出所有纠删代码 profile 的名称：

ceph osd erasure-code-profile ls

jerasure 插件是最通用的灵活插件。它也是 Ceph 纠删代码池的默认值。

jerasure 插件封装 JerasureH 库。有关参数的详细信息，请参阅 jerasure 文档。

要使用 jerasure 插件创建新的纠删代码配置集，请运行以下命令：

ceph osd erasure-code-profile set <name> \
     plugin=jerasure \
     k=<data-chunks> \
     m=<coding-chunks> \
     technique=<reed_sol_van|reed_sol_r6_op|cauchy_orig|cauchy_good|liberation|blaum_roth|liber8tion> \
     [crush-root=<root>] \
     [crush-failure-domain=<bucket-type>] \
     [directory=<directory>] \
     [--force]

其中：

默认 CRUSH 规则提供位于不同主机上的 OSD。例如：

chunk nr    01234567

step 1      _cDD_cDD
step 2      cDDD____
step 3      ____cDDD

需要 8 个 OSD，每个块对应一个。如果主机位于两个相邻的机架中，则前四个块可以放在第一个机架中，后 4 个放在第二个机架中。如果恢复单个 OSD 丢失，不需要在两个机架之间使用带宽。

例如：

crush-steps='[ [ "choose", "rack", 2 ], [ "chooseleaf", "host", 4 ] ]'

将创建一个规则，用于选择两个类型为 rack 的 crush bucket，并且分别选择四个 OSD，各自位于不同 bucket 中类型 的主机。

也可以手动创建该规则以进行更精细的控制。