构建一致性哈希ring Part2

最新推荐文章于 2024-05-28 22:08:12 发布
最新推荐文章于 2024-05-28 22:08:12 发布
阅读量2.9k 收藏
点赞数 1
分类专栏： python 算法 openstack swift 文章标签： import struct random 存储 byte 扩展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zzcase/article/details/6710104
版权
本文探讨了一致性哈希ring的构建过程，从ring3_0.py到ring4_1.py的改进，涉及节点扩容、分区分配、副本（replica）策略以及故障隔离的zone概念。通过随机化分区顺序解决了数据分布不均和故障隔离问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

******************转载请注明出处！**********

最后更新：2011年8月22日22:47:38


Part1中，已经构建好了一致性哈希ring的原型。

但存在一个问题。100个结点对应着1000个虚结点。结点变动时，虚结点和结点的对应关系会发生变化。当100个结点扩张到1001个时，会发生什么情况？

新增的结点数目会挤兑掉原先的结点数目！原因就在于1000个虚结点是固定的，不变化的。如果再扩容1000个虚结点->更改虚结点和实结点之间的对应关系->调整数据，这似乎又回到ring2_0.py的老套路。

这里做一些改动以更接近真实情况。

首先是vnode，以后改称为partition。因为partition数量很少会变动，所以需要充分估计到系统预期的规模。假如不会超过6000个结点，那么虚结点可以设置为实结点的100倍。这样，当虚结点需要调整的时候，最多只会影响到1%的数据。

在计算机中，数字取2的幂阶会有一些好处。比如除法只需要移相应的位就可以了。所以ring3_0.py中，结点数为65536(2^16)，partition数为8388608(2^23)个。


ring3_0.py

from array import array
from hashlib import md5
from struct import unpack_from
from time import time

PARTITION_POWER = 23
PARTITION_SHIFT = 32 - PARTITION_POWER
NODE_COUNT = 65536
DATA_ID_COUNT = 100000000

begin = time()
part2node = array('H')
for part in xrange(2 ** PARTITION_POWER):
    part2node.append(part % NODE_COUNT)
node_counts = [0] * NODE_COUNT
for data_id in xrange(DATA_ID_COUNT):
    data_id = str(data_id)
    part = unpack_from('>I',
                     md5(str(data_id)).digest())[0] >> PARTITION_SHIFT
    node_id = part2node[part]
    node_counts[node_id] += 1
desired_count = DATA_ID_COUNT / NODE_COUNT

print '%d: Desier data ids per node' % desired_count
max_count = max(node_counts)
over = 100.0 * (max_count - desired_count) / desired_count
print '%d Most data ids on one node, %.02f%% over' % (max_count, over)
min_count = min(node_counts)
under = 100.0 * (desired_count - min_count) / desired_count
print '%d Least data ids on one node, %.02f%% under' % (min_count, under)
print '%d seconds pass ...' % (time() - begin)
结果 

1525: Desier data ids per node
1683 Most data ids on one node, 10.36% over
1360 Least data ids on one node, 10.82% under
234 seconds pass ...

说明：

代码比较简单，part2node是node和partition的对应关系，node_counts记录着每个node中有多少个数据映射进来。

gholt特意提到系统开销：2Byte存储16位对应结点id， 600多万个partition只对应占用12MB的内存。gholt还提到ring3_0.py结果出现10%波动的问题。主要是因为数据空间(10^8相对于partition数(约8*10^6)太小了。他尝试过更大的数据空间空间，比如10^9个数据，对应于8*10^6的partition，耗时6个小时。-_-!


ring3_0.py已经有点接近现实中一致性哈希ring了，ring4_0.py中将加入replica的特性。


ring4_0.py

from array import array
from struct import unpack_from
from hashlib import md5
from time import time

REPLICAS = 3
PARTITION_POWER = 16
PARTITION_SHIFT = 32 - PARTITION_POWER
PARTITION_MAX = 2 ** PARTITION_POWER - 1
NODE_COUNT = 256
DATA_ID_COUNT = 10000000

begin = time()
part2node = array('H')
for part in xrange(2 ** PARTITION_POWER):
    part2node.append(part % NODE_COUNT) #(3)
node_counts = [0] * NODE_COUNT
for data_id in xrange(DATA_ID_COUNT):
    data_id = str(data_id)
    part = unpack_from('>I',
                     md5(str(data_id)).digest())[0] >> PARTITION_SHIFT
    node_ids = [part2node[part]] #(1)
    node_counts[node_ids[0]] += 1
    for replica in xrange(1, REPLICAS):
        while part2node[part] in node_ids: #(2)
            part += 1
            if part > PARTITION_MAX:
                part = 0
        node_ids.append(part2node[part])
        node_counts[node_ids[-1]] += 1
desired_count = DATA_ID_COUNT / NODE_COUNT * REPLICAS
print'%d: Desired data ids per node' % desired_count
max_count = max(node_counts)
over = 100.0 * (max_count - desired_count) / desired_count
print'%d: Most data ids on one node, %.02f%% over' % (max_count, over)
min_count = min(node_counts)
under = 100.0 * (desired_count - min_count) / desired_count
print'%d: Least data ids on one node,%.02f%% under' % (min_count, under)
print'%d seconds pass ...' % (time() - begin)
结果： 

117186: Desired data ids per node
118133: Most data ids on one node, 0.81% over
116093: Least data ids on one node,0.93% under
52 seconds pass ...

说明：

#(1) node_ids记录的是3个replica存放的node id。part2node[part]是根据对应的partition id 找到对应的node id。

#(2)处循环3次，依次为数据的replica安排连续的partition。之后改变相应的记录，node_ids.和node_counts。

ring4_0.py看起来还不错，1%的波动。可是仍然会有两个问题：

1. #(2)处是分配连续的partition。#(3)处初始化时是有规律的。这会在一些情况下使部分数据表现很糟糕。比如这部分数据被映射到node x的partition N上，node x频繁宕机，而总是partition N上的数据需要进行复制。解决也相对容易： part2node初始化时进行随机打乱，partition N和node x不在存在某种联系。

2 数据安全的问题。假如replica所在的partiton都分布在同一个机架上。机架掉电，这会导致所有replica都不可用。因此需要一种机制对故障进行隔离。因此也就引入了zone的概念。


ring4_1.py

from array import array
from struct import unpack_from
from hashlib import md5
from time import time
from random import shuffle

REPLICAS = 3
PARTITION_POWER = 16
PARTITION_SHIFT = 32 - 16
PARTITION_MAX = 2 ** PARTITION_POWER - 1
NODE_COUNT = 256
ZONE_COUNT = 16
DATA_ID_COUNT = 10000000

begin = time()
node2zone = []
while len(node2zone) < NODE_COUNT: #(1)
    zone = 0
    while zone < ZONE_COUNT and len(node2zone) < NODE_COUNT:
        node2zone.append(zone)
        zone += 1
part2node = array('H')
for part in xrange(2 ** PARTITION_POWER):
    part2node.append(part % NODE_COUNT)
shuffle(part2node)  #(2)
node_counts = [0] * NODE_COUNT
zone_counts = [0] * ZONE_COUNT
for data_id in xrange(DATA_ID_COUNT):
    data_id = str(data_id)
    part = unpack_from('>I',
                     md5(str(data_id)).digest())[0] >> PARTITION_SHIFT
    node_ids = [part2node[part]]
    zones = [node2zone[node_ids[0]]]
    node_counts[node_ids[0]] += 1
    zone_counts[zones[0]] += 1
    for replica in xrange(1, REPLICAS):  #(3)
        while part2node[part] in node_ids and \
        node2zone[part2node[part]] in zones:
            part += 1
            if part > PARTITION_MAX:
                part = 0
        node_ids.append(part2node[part])
        zones.append(node2zone[node_ids[-1]])
        node_counts[node_ids[-1]] += 1
        zone_counts[zones[-1]] += 1
        
desired_count = DATA_ID_COUNT / NODE_COUNT * REPLICAS
print '%d Desired data ids per node' % desired_count
max_count = max(node_counts)
over = 100.0 * (max_count - desired_count) / desired_count
print '%d: Most data ids on one node, %.02f%% over' % (max_count, over)
min_count = min(node_counts)
under = 100.0 * (desired_count - min_count) / desired_count
print '%d: Least data ids on one node,%.02f%% under' % (min_count, under)

desired_count = DATA_ID_COUNT / ZONE_COUNT * REPLICAS
print'%d: Desired data ids per zone' % desired_count
max_count = max(zone_counts)
over = 100.0 * (max_count - desired_count) / desired_count
print'%d: Most data ids in one zone, %.02f %% over' % (max_count, over)
min_count = min(zone_counts)
under = 100.0 * (desired_count - min_count) / desired_count
print'%d: Least data ids in one zone, %.02f %%under' % (min_count, under)
print '%d seconds pass ...' % (time() - begin)
结果： 

117186 Desired data ids per node
118619: Most data ids on one node, 1.22% over
115810: Least data ids on one node,1.17% under
1875000: Desired data ids per zone
1879143: Most data ids in one zone, 0.22 % over
1871851: Least data ids in one zone, 0.17 %under
69 seconds pass ...

说明：

#(1)zonelist初始化。引入zone，以解决ring4_0.py问题2。

#(2) part2node洗牌，打乱顺序。解决ring4_0.py问题1。花的时间比较多。

#(3) 逐次探查partition位置是否合适，不能在同一个node上，也不能在同一个zone上。

 


到此，ring的基本功能都已经有了：一致性哈希ring，replica，zone。ring4_2.py给出类似图2.1的实现。当然，只是一种实现模型。swift曾经采用过这种模型，但现已废弃。这里权当扩展了解，不感兴趣的请跳到下一Part。Part3将把上述的特性封装成类，加入weight，并简单测试。

 

ring4_2.py体现的是一种anchor思想。即：维护一个node的anchor环。每次data都会查找anchor环找到和匹配自己的存储node位置。

anchor环就是ring4_2.py中的hash2index和index2node。每个数据都在#(2)处查找index，之后到index2node找对应的node。#(1)中的二分查找、hash计算都是比较耗时的。系统开销暂不提，这种实现并不能够均匀分布数据。为使数据分布的更为均匀，每个node都要维护anchor，不断遍历anchor环以查找合适位置。而且，这种情况下replica的管理会非常麻烦。

空间和时间，计算机中的博弈。ring4_1.py采用的空间换时间，简化了对应关系；而ring4_2.py采用了时间换空间，思路简单，但效果不尽人意。


ring4_2.py

from bisect import bisect_left
from hashlib import md5
from struct import unpack_from
from time import time

REPLICAS = 3
NODE_COUNT = 256
ZONE_COUNT = 16
DATA_ID_COUNT = 10000000
VNODE_COUNT = 100

begin = time()
node2zone = []
while len(node2zone) < NODE_COUNT:
    zone = 0
    while zone < ZONE_COUNT and len(node2zone) < NODE_COUNT:
        node2zone.append(zone)
        zone += 1
hash2index = []
index2node = []
for node in xrange(NODE_COUNT):
    for vnode in xrange(VNODE_COUNT):
        hsh = unpack_from('>I', md5(str(node)).digest())[0]
        index = bisect_left(hash2index, hsh)
        if index > len(hash2index):
            index = 0
        hash2index.insert(index, hsh)
        index2node.insert(index, node)
node_counts = [0] * NODE_COUNT
zone_counts = [0] * ZONE_COUNT
for data_id in xrange(DATA_ID_COUNT):  #(1)
    data_id = str(data_id)
    hsh = unpack_from('>I', md5(str(data_id)).digest())[0]
    index = bisect_left(hash2index, hsh)  #(2)
    if index >= len(hash2index):
        index = 0
    node_ids = [index2node[index]]
    zones = [node2zone[node_ids[0]]]
    node_counts[node_ids[0]] += 1
    zone_counts[zones[0]] += 1
    for replica in xrange(1, REPLICAS):
        while index2node[index] in node_ids and node2zone[index2node[index]] in zones:
            index += 1
            if index >= len(hash2index):
                index = 0
        node_ids.append(index2node[index])
        zones.append(node2zone[node_ids[-1]])
        node_counts[node_ids[-1]] += 1
        zone_counts[zones[-1]] += 1
desired_count = DATA_ID_COUNT / NODE_COUNT * REPLICAS
print '%d: Desired data ids per node' % desired_count
max_count = max(node_counts)
over = 100.0 * (max_count - desired_count) / desired_count
print '%d: Most data ids on one node, %.02f%% over' % (max_count, over)
min_count = min(node_counts)
under = 100.0 * (desired_count - min_count) / desired_count
print '%d: Least data ids on one node, %.02f%% under' % (min_count, under)

desired_count = DATA_ID_COUNT / ZONE_COUNT * REPLICAS
print '%d: Desired data ids per zone' % desired_count
max_count = max(zone_counts)
over = 100.0 * (max_count - desired_count) / desired_count
print '%d: Most data ids on one zone, %.02f%% over' % (max_count, over)
min_count = min(zone_counts)
under = 100.0 * (desired_count - min_count) / desired_count
print '%d: Least data ids on one zone, %.02f%% under' % (min_count, under)

print '%d seconds pass ...' % (time() - begin)
结果： 

117186: Desired data ids per node
351282: Most data ids on one node, 199.76% over
15965: Least data ids on one node, 86.38% under
1875000: Desired data ids per zone
2248496: Most data ids on one zone, 19.92% over
1378013: Least data ids on one zone, 26.51% under
990 seconds pass ...



Hash 算法：原理与应用
AI智能涌现深度研究
08-31 297
哈希（Hash）算法，也称为散列算法，是计算机科学中一种重要的基础算法。它通过将任意长度的输入数据转换成固定长度的输出数据的方式，在数据存储、查找、加密和验证等多个领域发挥着关键作用。自20世纪50年代首次提出以来，哈希算法已经发展成为现代计算机科学和信息安全领域不可或缺的工具。随着互联网技术和大数据时代的到来，哈希算法在处理海量数据、保护信息安全和优化系统性能等方面的应用愈发广泛。本文将深入探讨哈希算法的原理、特性和应用，旨在帮助读者全面理解这一重要的算法概念。
[openstack swift]1 swift安装(1)
预则立 不预则废
07-04 9432
说明：这里用来举例的是swift 1.1。文章成稿时的最新版本为swift1.4.2-dev。两个版本之间有很大区别，但整体结构上变化不大，并不影响对swift的理解。swift1.4.*版本的简明安装会在稍后更新。特此说明。     1swift安装 约定 ubuntu 用户：swift swift用户 home 目录： /home/swift swift工作目录： /etc/
构建一致性哈希ring Part1
预则立 不预则废
08-22 6341
******************转载请注明出处！********** 最后更新：2011年8月22日22:29:01 写在前面。 原打算只从代码角度做些swift ring的分析工作。但无意中看到了gholt的文章，收益良多，便动了翻译的念头。 “翻译向来
自动化构建：一致性关键之道
cpongo5
03-06 483
介绍\如果有那么一件事软件开发人员很在行（并非引述电影《黑客》），那一定是将通常需要人工完成的任务自动化。让计算机处理重复乏味的任务将使得大家生活得更轻松，这里我们讨论的是如何让大家专注于他们所关心的事情。然而，研发团队时常会忽略那个最有帮助的受众—他们自己。\在为数众多的中小型软件作坊中，不存在自动化构建和发布工具。构建、交付准备环境、代码发布全由手工完成，同样还有运行测试、备份旧版本、新版本打...
构建制品不一致，后续工作都是白费
BYvonne的博客
02-09 721
本篇文章，我们从软件交付的终态出发，提出了不可变构建的概念。在软件开发的过程中，我们怎样才能享受产业生态的红利，实现软件交付过程的标准化呢？软件交付当中的集装箱应该是什么样的？
关于Python3.6无法使用hash_ring库
qq_35225554的博客
02-11 1102
最近在了解推荐系统的相关算法，在学习到一致性hash算法的时候，了解到，Python 已经有人造好轮子了，所以可以直接的使用，在使用的过程中，出现了一些错误，好在错误原因比较简单，解决的比较快，下面是错误解决方案： 如往常一样在linux的已经激活的Python虚拟环境上使用pip安装相关库hash_ring pip install hash_ring 在安装成功后，打开Python，使用...
三分钟看懂一致性哈希算法
热门推荐
gerryke的blog
12-30 4万+
受一篇“五分钟看懂”的启发，来个哗众取宠的标题 一致性哈希算法，作为分布式计算的数据分配参考，比传统的取模，划段都好很多。 在电信计费中，可以作为多台消息接口机和在线计费主机的分配算法，根据session_id来分配，这样当计费主机动态伸缩的时候，因为session_id缓存缺失而需要放通的会话，会明显减少。 传统的取模方式 例如10条数据，3个节点，如果按照取模的方式，那就是
一致性哈希
weixin_34138521的博客
12-06 57
在 1997 年，MIT 的计算机科学实验室研究员David Karger, Eric Lehman, Tom Leighton, Matthew Levine, Daniel Lewin, Rina Panigrahy 等发表了论文《Consistent hashing and random trees: distributed caching pr...
Python实现一致性hash（不设置虚拟节点与设置虚拟节点的对比）
暗焰之珩的博客
10-09 3226
一致性hash的原理介绍，前人已经做的很清楚了，可以参看下面链接： 一致性HASH算法详解 上文美中不足的是，数据结构的设计较复杂，hash环的实现，属性用简单的列表和字典实现即可。 一致性哈希（不设置虚拟节点） 首先放不设置虚拟节点的代码，可以看见删除掉某个节点时很容易引起雪崩效应，代码如下。 """对一致性hash进行学习，构造没有vnode的hash，增加和删除节点以进行观察，会...
【系统架构级别的性能优化】分布式设计：一致性哈希与跨数据中心部署
[【系统架构级别的性能优化】分布式设计：一致性哈希与跨数据中心部署](https://www.interviewhelp.io/blog/images/consistent-hashing.png) # 1. 分布式系统的基本概念与挑战 ## 1.1 分布式系统简介 分布式系统是...
哈希算法教程（个人总结版）
最新发布
年糕的博客
05-28 4557
哈希算法（Hash Algorithm）是一种将任意长度的输入（也称为消息）转换为固定长度的输出（也称为哈希值、散列值、摘要）的算法。SHA-256（Secure Hash Algorithm 256-bit）是SHA-2（Secure Hash Algorithm 2）家族中的一种，广泛应用于安全性要求较高的场景，如区块链、数字签名等。散列函数用于哈希表（Hash Table）等数据结构中，将数据映射到固定大小的数组上，以实现高效的数据存储和检索。哈希算法可以用于数据库的索引，提高数据检索的效率。
构建Ring的过程
实践求真知
03-29 703
一 介绍Ring是swift中非常核心的组件，它决定着数据如何在集群中分布。Swift根据设置的partition_power决定集群中的分区数量（2的partition_power次方），并根据一致性哈希算法将分区分配到不同的node上，并将数据分布到对应的分区上。二 新的Ring创建的过程1 ring-builder根据device weight计算出每个设备上应该被分配的分区的数量。（2的p...
Python3.x 环境下安装使用hash_ring库
Yucen的博客
02-21 2497
hash_ring库安装 pip install hash_ring 修改使其在Python3.x 环境下能用 安装成功后，在程序里直接加载hash_ring库 from hash_ring import * 会报错如下: Traceback (most recent call last): File "D:\ProgramData\Anaconda3\lib\site...
[openstack swift]2基本概念
预则立 不预则废
07-21 8659
最后更新：2011年7月21日16:19:49 swift 的基本概念
[openstack swift]0 swift介绍
预则立 不预则废
07-01 6873
 0 swift 介绍 0.1swift 是什么？ OpenStack Object Storage 最开始是由 Rackspace 开发，并于 2010 年 7 月贡献给 OpenStack ，作为其开源子项目。 OpenStack Object Storage 最初作为 RackspaceCloud Files service 的主体实现，工程代号为 swift 。因此 swift 沿用至今。
[openstack swift]1 swift安装(2)
预则立 不预则废
07-04 6845
说明：这里用来举例的是swift 1.1。文章成稿时的最新版本为swift1.4.2-dev。两个版本之间有很大区别，但整体结构上变化不大，并不影响对swift的理解。swift1.4.*版本的简明安装会在稍后更新。特此说明。 更新时间：2011年8月22日16:48:32
[openstack swift]3 其他相关(2)
预则立 不预则废
08-02 6409
******************转载请注明出处！********** 最后更新：2011年8月2日17:55:11 注：swift1.1版使用swift-auth-add-user生成用户，swift1.3之后用户信息全部记录在proxy-server
[openstack swift]4 悬而未决的问题和几点考虑
预则立 不预则废
08-03 5191
******************转载请注明出处！********** 最后更新：2011年8月3日20:51:36 4 悬而未决的问题和几点考虑 4.1如何避免SDC？ SDC全称Silent Data Corruption。正如AMD给出的解释：“SDC occurs when incorrect data is delivered by a computing syst
[openstack swift]3 其他相关
预则立 不预则废
08-01 4381
******************转载请注明出处！********** 最后更新：2011年8月1日20:22:35 3.1CAP原则和swift的联系     这个idiot的小节源自淘宝网某某问我的一个问题：     “swift为什么不用RAID？sw
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值