Changing Requirements for Distributed File Systems in Cloud Storage

Transcription

1 Changing Requirements for Distributed File Systems in Cloud Storage Wesley Leggette Cleversafe

2 Presentation Agenda r About Cleversafe r Scalability, our core driver r Object storage as basis for filesystem technology r Namespace-based routing r Distributed transactions r Optimistic concurrency r Designing an ultra-scalable filesystem r Filesystem operations on object layer r Conclusions 2

3 About Cleversafe r We offer scalable storage solutions r Target market is massive storage (>10 PiB) r Information Dispersal Algorithms (Erasure Codes) r Reduce cost by avoiding replication overhead r Maximize reliability by tolerating many failures r Object storage core product offering r How to translate this technology to filesystem space r Evolution from object storage concepts r Also influenced by distributed databases and P2P r Techniques we investigate not unique to IDA

4 How Dispersed Storage Works 1. Digital Assets divided into slices using Information Dispersal Algorithms IDA Total Slices = width = N Digital Content 8h$1 vd@- fmq& Z4$ >hip )aj% l[au T0kQ Site 1 %~fa Uh(k My)v 9hU6 >kir 4Wco 2. Slices distributed to separate disks, storage nodes and geographic locavons Site 2 vd@- pyvq Site 3 Site 4 8h$1 &i@n >hip )aj% l[au %~fa IDA 9hU6 >kir pyvq 4Wco 3. A threshold number of slices are retrieved and used to regenerate the original content

5 Access Methods Simple Object HTTP Accesser Exposes HTTP REST API We sell two deployment models Application Server HTTP Accesser Object ID Database Stores metadata dsnet Protocol Multiple Accessers can be load balanced for increased throughput and availability. The Accesser returns a unique 36 Character Object ID Simple Object Client Library Accesser Function Embedded into the Client Application Server Object ID Database Java Client Library OBJECT VAULT These are clients in context of this presentation dsnet Protocol Stores metadata Accesser functionality including slicing and dispersal is contained within the client library OBJECT VAULT

6 Scalability A Primary Requirement r Big Data customers are petabyte to exabyte scale r Scale out architecture r Add storage capacity with commodity machines r Reduce costs: commodity hard drives r Invariants r Reliability keep data even as cheap disks fail r Availability access data during node failures r Performance linear performance growth 6

7 Scale Example r Shutterfly r 10 PB Cleversafe dsnet storage system r All commodity hard drives r Single storage container for all photos r 10 s thousands of large photos stored per minute r Max capacity many times this level r 14 access nodes for load balanced read/write r No single point of failure r Linear performance growth with each new node r This uses object storage product

8 Investigating Filesystem Space r We have scalable object storage r Limitless capacity and performance growth r Fully concurrent read/write r Some customers want the same with a filesystem r Is this technically possible? r What tradeoffs would have to be made?

9 Scale comes from homogeneity Client Storage Client Client Storage Storage Scalable Client Storage Client Storage Client Client Metadata Storage Storage Not Scalable Client Storage r To scale out, we need to do so at each layer r Eliminate central chokepoint for data operations r Central point of failure, central point of r We accomplish this today with object storage r Consider same concept in a filesystem

10 What approach can we take? r Start with scalable transactional object storage r Add filesystem implementation on top Transactional Object Storage IDA + Distributed Transaction Client Namespace-based Storage Routing Session Management (Multi-path) Object Reliability Namespace Remote Session Filesystem Object Reliability Namespace Remote Session r Object r Check-and-write transactions r Reliability r Ensures committed objects reliable and consistent r Namespace r Routes actual data storage r No central I/O manager

11 Namespace Object Reliability Namespace Remote Session

12 Traditional Centralized Routing Client Routing Master 1 Object 10,000 req/s Storage 2 Reliability 640 req/s Storage Storage Namespace Remote Session Storage MAX 15 Servers! Central controller directs traffic r Easier to implement, allows simple search r Detect conflicts, control locking r Does not scale-out with rest of architecture r Today, 10PB system needs disk nodes* r These nodes can service 57,600 2MB req/s** r Central point of failure = less availability r * 3TB drives, some IDA overhead **10Gbps NIC, nodes saturate wire speed

13 Namespace-based Routing 4-wide Vault 8-wide Vault Index 0 7 Object Index 0 3 H A H A 1 6 Reliability Namespace G B G B F C F C E D Remote Session 1 E 4 D 3 Namespace concept from P2P systems r Chord, CAN, Kademila r MongoDB, CouchDB production examples r Physical mapping determined by storage map r Small data (<10KiB) loaded at start-up r r P2P systems use dynamic overlay protocol r We ll have 10 s thousands of nodes, not millions

14 Storing Data in a Namespace Object r Reliability Namespace No central lookup for data I/O 1. Generate object id 2. Map to storage Remote Session Object ID Source Name Slice Name Slice Name Slice Name Storage Map With object storage, object id à database r How do we map file name to object id? r

15 Reliability Object Reliability Namespace Remote Session

16 Replication and Eventual Consistency Object Reliability Namespace Remote Session Eventual consistency often used with replication r Client writes new versions to available nodes r Versions sync to other replicas lazily r Application responsible for consistency r Already true in filesystems r Allows partition tolerant systems r COPY 1 Now Later Client A COPY 2 REPAIR 3 Client B Read sees old version REPAIR 4

17 Dispersal Requires Consistency Reliability Namespace Remote Session Dispersal doesn t store replicas r Threshold of slices required to recover data r Crash during unsafe periods can cause loss r Methods to prevent loss r Three-phase distributed transaction r Width: 4 Threshold: 3 Time Object r Commit: Safe Safe UNSAFE Safe All revisions visible during unsafe period r Finalize: Cleanup when new version commit safe r Quorum-based r Writes voting fail if <T successful

18 Three-Phase Commit Protocol Object 2-Phase Commit Protocol Reliability Namespace Remote Session 1 WRITE COMMIT 2 Width: 4 Threshold: 3 Commit Failure Causes Loss! X X 3-Phase Commit Protocol 1 WRITE COMMIT 2 3 FINALIZE/UNDO X X

19 Consistent Transactional Interface Object Reliability Namespace Remote Session r Distributed transaction makes dispersal safe r All happens in client, no server coordination r Write consistency r Side-effect of distributed transactions r Writes either succeed or fail atomically r Limitation: Consistency = less partition tolerance r CAP Theorem (we also choose availability) r Either read or write fails during partition r Still shardable : affects availability, not scalability r Is consistency useful for filesystem directories?

20 Object Object Reliability Namespace Remote Session

21 Write-if-absent for WORM Object Reliability Namespace Remote Session r Object storage is WORM r Enforced by underlying storage r Write-if-absent model built on transactions r Distributed transactions emulate atomicity r Checked write fails if previous revision exists WRITE IF PREVIOUS = Client A Client B ' WRITE IF PREVIOUS = Success Failure

22 Optimistic Concurrency Control Object Reliability Namespace Remote Session Client A WRITE IF PREVIOUS = Client A WRITE IF PREVIOUS = 1 Client A ' Client B 1 Success Success WRITE IF PREVIOUS = 1 Success WRITE IF PREVIOUS = 1 Failure V3 Success READ, REDO ACTION 2 3 V3 WRITE IF PREVIOUS = 2 Easy to extend this model to multiple revisions r Write succeeds IFF last revision matches given r Basis for optimistic concurrency r How do concurrent writers update a directory? r

23 Filesystem Filesystem Object Reliability Namespace Remote Session

24 Ultra-Scalable Filesystem Technology Filesystem Object r Filesystem layer on top of object storage r Scalable no-master storage r Inherits reliability, security, and performance r How do we map file name to object id? r Is consistency useful for filesystem directories? r How do concurrent writers update a directory?

25 Object-based directory tree How do we map file name to object id? r Directories stored as objects r Filesystem structure as reliable as data r Directory content data is map of file name to object id r Object id points to another object on system r Id for content data r Id for metadata (xattr, etc) r Data objects WORM r Zero-copy snapshot support r r Reference r counting Well known object id for root

26 Directory Internal Consistency r Is consistency useful for filesystem directories? r Object layer allows atomic directory updates r This mimics model used by traditional filesystems r Content data stored in separate immutable storage r Safe snapshot support r Eventual consistency r Temporary effects r Writes: Orphaned data r Deletes: Read error r Absolute requirement? No.

27 Concurrency Requires Serialization r How do concurrent writers update a directory? r Updates to directory entries are atomic (definition) r More precisely, filesystem operations are serialized r Client A adds file, Client B adds file, Client C deletes file r First to call wins, application must have sane order r Kernels use mutexes (locks) for serialization r Master controller (pnfs, GoogleFS) does this r We want to use multiple/no master model r Distributed locking protocols exist (e.g., PAXOS) r It s hard: Protocols complex and have drawbacks r It s slow: Overhead for every operation

28 Optimistic Concurrency r We want to serialize without locking r Observation: File writes have two steps r Write the data (long, no contention)* r Modify the directory (short, serialized)** r Use checked writes for directory r Always read directory before writes r Write new revision if-not-modified-since r On write conflict, re-read, replay, repeat * Consider workload where files > 1 MiB, we write content data in WORM storage ** Because directories stored as as objects themselves, modifying directory is re-writing object

29 Lockless Directory Update r Optimistic concurrency guarantees serialization r Operation is simple ( add file ), so replay trivial r On conflict, operation replay semantics are clear r Content data (large) is not rewritten on conflict r Highly parallelizable r Potentially unbounded contention latency r Back-off protocol can help r Not good for high directory contention use cases

30 Conclusions r Advantages r Limitations r Final Thoughts

31 Advantages r Scalability and Performance r Content data I/O quick and contention free r No-master concurrent read and write r Linearly scalable performance r Availability r Load balancing without complicated HA setups r Reliability r Information dispersal r Both data and metadata have same reliability r No separate backup required for index server

32 Limitations r Optimistic concurrency sensitive to high contention r Cache requirements limit directory size r No intrinsic limit, but a 100MiB directory object? r No central master makes explicit file locking hard r SMB, NFS protocols support these r Not suitable for random-write workloads r Not suitable for majority small file workloads r Directory write times eclipse file write times r Requires separate index service for search

33 Final Thoughts r Significant advances come from P2P and NOSQL space r Three key techniques allow for ultra-scalable FS r Namespace-based routing r Distributed transactions using quorum/3-phase commit r Optimistic concurrency using checked write r Techniques useable with IDA or replicated systems r Filesystem would not be general purpose r Techniques have some trade-offs r Excellent for specific big data use cases

34 Questions?