Two planes: the index says where, storage holds what

Metadata and bytes scale on different axes, so the store splits into an index plane (key → fragment locations) and a data plane (dumb nodes holding fragments) — and a GET resolves the key, reads k fragments, reconstructs if any are missing, verifies, and streams.

Previously

Fragments are now spread across failure domains for safety — so something has to remember which storage node holds which fragment. That something is the index plane, and wiring it to the storage nodes gives us the whole read path.

Scene 06

Two planes: the index says where, storage holds what

Watch
Try it
Predict
Capture

What to watch for

A GET arrives. The Frontend authenticates the request, asks the index plane where this key's fragments live, reads k fragments from the storage nodes in parallel, verifies a checksum, and streams the bytes back. Watch the ribbon walk the path.

Left to right: a Frontend that takes a request, an index plane (a keymap from each object key to the list of storage nodes holding its fragments — the WHERE), and a data plane (a row of dumb storage nodes, each holding one fragment — the WHAT).
A GET walks the top ribbon: authenticate, look up the index, read k fragments, reconstruct if any are missing, verify a checksum, stream.

Implementation

Highlighted lines are the ones running in the diagram right now.

Frontend.get

resolve the key, read k fragments, rebuild if any are missing

1def get(bucket, key):
2    authenticate(request)
3    # ask the index plane WHERE the fragments live
4    meta = index.lookup(bucket, key)
5    if meta is None:
6        return 404            # nothing points at any bytes
7    frags = read_parallel(meta.locations)   # data plane
8    if any_missing(frags):
9        # degraded read: pull parity, solve for the gap
10        frags = reconstruct(frags, meta.parity)
11    obj = concat(frags)
12    verify(checksum(obj), meta.checksum)
13    return stream(obj)

IndexPlane.lookup

the keymap: key → fragment locations, scaled apart from bytes

1# the index plane — one tiny row per object
2# rows scale with OBJECT COUNT, not byte volume
3def lookup(bucket, key):
4    shard = route_by_key(bucket, key)  # flat keyspace
5    row = shard.get(key)
6    if row is None:
7        return None        # source of truth for existence
8    return row   # locations, parity, checksum, size

Sources

Where this sits in Build an S3-style distributed object store

Scene 06 of 12, in the Keep it alive act — Erasure coding, placement, the two planes, and repair.. Index plane vs data plane; trace a GET (read k, reconstruct, verify, stream) and a PUT's atomic index commit.

Up next. We can now read and write an object — but we still haven't answered the opening mystery of how the nines survive weekly disk death; the plane split is exactly what lets a background loop fix it.

All 12 scenes in Build an S3-style distributed object store · Every curriculum

Built with Arqly

Every scene in Build an S3-style distributed object store builds on the one before it.All 12 Build an S3-style distributed object store scenes