veyepar: Make a bigger pie: Updating the partition count in a consistent hash ring

Author(s):	John Dickinson
Location	Guthrie Theatre CB06.03.28
Date	jan Wed 24	Days Raw Files
Start	13:40	First Raw Start	13:10
Duration	0:45:0	Offset	0:29:41
End	14:25	Last Raw End	14:40
Chapters	00:00 0:28:33
Total cuts_time	43 min.

http://lca2018.linux.org.au/schedule/presentation/26/
raw-playlist raw-mp4-playlist encoded-files-playlist host archive public tweet mp4 svg png

assets release.pdf Make_a_bigger_pie_Updating_the_partition_count_in_a_consistent_hash_ring.json
logs
Admin: episode episode list cut list raw files day marks day marks day image_files

State:

Locked:

clear this to unlock

Locked by:

user/process that locked.

Start:

initially scheduled time from master, adjusted to match reality

Duration:

length in hh:mm:ss

Name:

Video Title (shows in video search results)

Emails:

email(s) of the presenter(s)

Released:

has someone authorised pubication

Normalise:

Channelcopy:

m=mono, 01=copy left to right, 10=right to left, 00=ignore.

Thumbnail:

filename.png

Description:

markdown

Consistent hash rings are often used in distributed storage systems to efficiently compute data placement. However, for efficiency, these hash rings are often implemented with a fixed number of partitions of the key space. This is how OpenStack Swift's data placement algorithm works. Swift's "part power" is used to segment, or partition, the consistent hash ring used for placement. The part power is set when the ring is created, and it determines the upper limits of capacity in the cluster.

Unfortunately, if the partition count is set too high, there will be excessive overhead in the system and storage capacity will be underutilized. However, if it is set too low, then data placement will get "lumpy" and be unevenly distributed across the cluster. An operator is forced to balance these two concerns, often without knowing how much the cluster will grow.

Recently the Swift community has merged a feature that allows operators to increase the partition power in an existing cluster. This allows operators to set the part power to a low value when the cluster is created and increase it over time as the cluster expands. Implementing this feature is tricky, because the part power is a fundamental part of the data placement algorithm. Changing it can potentially make all of the data in the cluster completely inaccessible. Swift's implementation, however, is able to keep the cluster available during the entire process.

This talk will describe the data placement problem, explain how the community implemented the feature, and give a short demo of the feature in action.

Comment:

production notes