Blobasaur: Shard-basiertes Blob-Storage mit SQLite

Werkbank in einem Hardware- und Robotiklabor mit Messgeraeten, Kabeln und zerlegten Geraeten
Deine Reaktion:

Blobasaur verarbeitet auf handelsüblicher Hardware rund 25.000 Schreiboperationen pro Sekunde und hält die p99-Latenz bei 8,3 Millisekunden. Damit betreibt die Plattform ein verteiltes Blob-Storage auf SQLite-Basis, das mehrere hunderttausend Blobs parallel bedient. Hinter dem Projekt steckt ein nüchterner Perspektivwechsel: Nicht das Dateisystem, sondern eine eingebettete Datenbank übernimmt die Details einer eigenen Speicherarchitektur.

Der Auslöser war eine Kombination aus Produktanforderungen und Betriebsrealität. Die Zerodha-Plattform Kite bietet stark personalisierbare Investment- und Trading-Ansichten. Nutzer speichern dort mehrstufige Chart-Layouts, Finanzindikatoren, vektorbasierte Zeichnungen, Terminal-Konfigurationen und zahlreiche weitere Oberflächenpräferenzen. Diese Daten werden als undurchsichtige Blobs behandelt, meist JSON-Dokumente mit einer Größe von wenigen Kilobyte bis hin zu mehreren Megabyte.

Die anfängliche Lösung CouchDB war für das wachsende Durchsatzniveau ungeeignet. Danach übernahm SSDB die Aufgabe, ein datenbankgestützter Key-Value-Speicher mit Redis-Protokoll. Die Migration war einfach, und SSDB lief mehrere Jahre zuverlässig. Langfristig entstanden jedoch zwei Probleme: Das Projekt war nicht mehr gepflegt, und die Technologie ließ sich ohne erheblichen Aufwand nicht in das eigene Stack-Umfeld integrieren. Hinzu kam eine zentrale Grenze: SSDB war nicht verteilt und blieb auf einen einzigen Knoten beschränkt.

Als die Blobs größer wurden, stieg die Latenz. Zeitweise musste das System die Blob-Größe auf 1 MB begrenzen. Mit dem Terminal-Modus und weiteren internen Anwendungen entstand außerdem ein Bedarf an horizontaler Skalierung. Aus dieser Lage heraus formulierte Zerodha fünf Leitplanken: eine einfache Key-Value-API, zuverlässige Lese- und Schreibvorgänge für mehrere Megabyte, horizontale Verteilung, gute Plattennutzung und ein wirtschaftlich sowie operativ wartbarer Aufbau.

Die Auswahl bekannter Datenbanken und ihre Grenzen

Zerodha prüfte zunächst mehrere verbreitete Datenbanken, statt SQLite direkt als Selbstverständlichkeit zu behandeln. ScyllaDB war bereits für andere hoch Durchsatz-intensive Workloads im Einsatz, zeigte sich in den Tests aber bei großen Blobs ungeeignet. Häufige Überschreibungen hinterließen Tombstones, während TTL-Ablaufzeiten zusätzliche Optimierung erforderten. Auch Durchsatz und Ressourcenverbrauch lagen bei Mehr-Megabyte-Payloads nicht im gewünschten Bereich.

PostgreSQL bot bereits vorhandene Betriebserfahrung, erwies sich beim Speichern von Blobs als BYTEA-Spalten jedoch ebenfalls als Performance- und Plattenplatzproblem. YugabyteDB verfügte über Blob-Funktionen, war aber nicht primär dafür ausgelegt und wirkte für den konkreten Zweck zu umfangreich. RocksDB besaß passende Bausteine, war jedoch nicht auf die parallele Verarbeitung großer Schreibvorgänge mit mehreren Megabyte ausgerichtet.

Objektspeicher wie Ceph und S3 beziehungsweise MinIO waren ebenfalls keine passende Antwort. Ceph hätte einen hohen operativen und infrastrukturellen Aufwand bedeutet. S3 und MinIO verursachten bei kleinen, häufig geschriebenen Objekten zu hohe Request-Latenzen und Kosten. Außerdem boten sie mit groben Lifecycle-Regeln keine exakte TTL-Steuerung pro Schlüssel. Das rohe Dateisystem verschob die Arbeit lediglich in die Anwendung: Atomizität, Schreib-Batching, TTL-Bereinigung, Metadaten, Dateideskriptoren und Inodes mussten selbst verwaltet werden.

SeaweedFS kam den Anforderungen am nächsten, hatte aber einige wesentliche Hürden. Der Store hängte bei Überschreibungen zunächst Daten an, bis eine Kompaktierung sie beseitigte. Bei einem überschreibungslastigen Zugriffsmuster konnte der Plattenverbrauch dadurch ungünstig wachsen. Zudem benötigte die Lösung eine zusätzliche Zuordnung zwischen Blob-IDs und Anwendungsschlüsseln und unterstützte keine TTL direkt pro Blob. Der Betrieb mehrerer Komponenten wäre ebenfalls aufwendig gewesen.

Die zentrale Lehre lautet: Nicht jede bewährte Datenbank eignet sich für jede Zugriffsform. Eine Datenbank kann bei tausenden kleinen Key-Value-Abfragen hervorragend funktionieren und beim parallelen Schreiben großer JSON-Blobs trotzdem an Grenzen stoßen. Entscheidend ist deshalb nicht nur die Architektur des Produkts, sondern die Übereinstimmung zwischen Datenmodell, Schreiblast, Objektgröße und Betriebsanforderungen.

SQLite als Fundament für einfache Blob-Speicherung

Der entscheidende Impuls kam aus einem anderen Projekt, bei dem Zerodha die SQLite-Aussage prüfte, sie sei bis zu 35 Prozent schneller als das Dateisystem. Gleichzeitig erzeugte ein Query-Cache bereits täglich Millionen Tabellen in PostgreSQL. Daraus entstand die Idee, SQLite als Grundlage eines eigenen Blob-Servers zu verwenden: Wie eine Datei pro Blob, nur mit den Funktionen einer Datenbank.

SQLite lieferte viele Bausteine, die das rohe Dateisystem nicht bot. Transaktionen sorgten für konsistente Änderungen, WAL-Modus erlaubte gleichzeitige Leser, und die Crash-Recovery war bereits erprobt. Expiry-Zeitpunkte konnten in einer eigenen Spalte liegen. Außerdem blieb die Lösung mit dem sqlite3-CLI und normalen SQL-Abfragen zugänglich. Für Analysen oder manuelle Prüfungen war das ein praktischer Vorteil gegenüber einem undurchsichtigen Binärformat.

Bei kleinen Blobs lag SQLite laut Messung sogar vor dem Dateisystem. Oberhalb von etwa 100 KiB konnte das Dateisystem schneller werden, doch vor der Speicherung wurde der Inhalt komprimiert. Rund 99 Prozent der komprimierten Werte blieben unter dieser Schwelle. Aus einem vermeintlichen Nachteil wurde damit eine Randbedingung, die das Design ohnehin benötigte.

Als Programiersprache chose Zerodha Rust. Der vorhandene Backend-Stack bestand überwiegend aus Go, der übliche Go-Treiber für SQLite benötigte jedoch CGo. Das erschwerte statische Builds, band unter hoher Nebenläufigkeit OS-Threads während C-Aufrufen und erzeugte zusätzliche Belastung durch die Speicherverwaltung. Mit Rust, sqlx, rusqlite und tokio ließ sich die SQLite-C-Schnittstelle direkter ansprechen. Das Ergebnis war eine einzelne statische Binary, die ohne mehrere Datenbankdienste oder weitere Laufzeitkomponenten auskam.

Sharding löst das SQLite-Schreibproblem

Im WAL-Modus kann SQLite mehrere Leser gleichzeitig bedienen, erlaubt aber nur einen Writer pro Datenbank. Da bei Zerodha ungefähr die Hälfte des Traffics aus Schreibvorgängen bestand, wäre eine einzelne SQLite-Datei schnell zum Engpass geworden. Blobasaur teilt die Daten deshalb auf mehrere physische SQLite-Dateien auf, sogenannte Shards.

Jeder Schlüssel wird über Multi-Probe Consistent Hashing genau einem Shard zugeordnet. Das ähnelt der Verteilung von Post-it-Zetteln auf mehrere Schubladen: Jeder Gegenstand hat einen festen Platz, sodass das System nicht bei jeder Anfrage sämtliche Schubladen durchsuchen muss. Die Hash-Funktion entscheidet jedoch nicht nur nach dem Namen, sondern berücksichtigt auch den Hash-Wert des nächsten Knotens im Ring. Das reduziert die Datenverschiebung, wenn Knoten hinzukommen oder entfernt werden.

Jeder Shard besitzt eine eigene Writer-Task mit einer begrenzten Warteschlange. Statt jede Änderung separat zu committen, entleert der Writer mehrere ausstehende Schreibvorgänge und verarbeitet sie gemeinsam in einer BEGIN IMMEDIATE-Transaktion. Das Verfahren heißt Group Commit. Vergleichbar ist es mit einer gemeinsamen Sammelabfahrt: Mehrere Passagiere werden nicht einzeln losgeschickt, sondern gemeinsam transportiert. Transaktions- und WAL-Overhead werden dadurch auf mehrere Operationen verteilt.

Leser greifen dagegen direkt auf einen Pool schreibgeschützter SQLite-Verbindungen des jeweiligen Shards zu. Sie können parallel zum Writer arbeiten, ohne auf dessen Schreibtransaktion zu warten. Diese Trennung von konkurrierenden Lese- und Schreibpfaden ist einer der Gründe, weshalb das System sowohl hohe Leseraten als auch hohe Schreibraten bedienen kann.

Messungen zeigen den Nutzen von 16 Shards

Ein Benchmark verglich einen Shard mit 16 Shards. Der Lastgenerator öffnete 64 gleichzeitige Verbindungen und schrieb 100.000 Schlüssel mit Payloads von jeweils 64 KiB. Diese JSON-Daten ließen sich mit zstd ungefähr neunfach komprimieren. Beide Varianten erhielten denselben Ressourcenrahmen mit 1.600 MB SQLite-Page-Cache und insgesamt 64 Leseverbindungen. Das Datenverzeichnis lag auf tmpfs, um SSD- oder Dateisystemvariationen von den SQLite-Locking-Effekten zu trennen.

Bei ausschließlich HSET stieg der Durchsatz von 7.740 auf 25.324 Operationen pro Sekunde. Die p99-Latenz sank von 10,7 auf 8,3 Millisekunden. In der gemischten Last mit 50 Prozent HSET und 50 Prozent HGET erhöhte sich der Durchsatz von 14.227 auf 29.538 Operationen pro Sekunde; die p99-Latenz fiel von 10,5 auf 8,5 Millisekunden. Bei ausschließlich lesenden HGET-Aufrufen blieb die Leistung nahezu unverändert.

Besonders auffällig war die medianale Schreiblatenz: Sie sank von 8,2 auf 2,1 Millisekunden. Der Lesedurchsatz blieb bei 67.128 beziehungsweise 70.884 Operationen pro Sekunde weitgehend stabil. Genau dieses Muster bestätigt die Architekturentscheidung. WAL verhindert bereits Leser-Locker-Konflikte innerhalb eines Shards. Sharding wirkt daher vor allem dort, wo SQLites einzelner Writer zu einem realen Produktionsproblem wird.

Bei 25.324 HSET-Operationen pro Sekunde verarbeitete das System rund 1,66 GB unkomprimiertes JSON pro Sekunde durch die zstd-Kompression. Server und Lastgenerator liefen allerdings auf demselben 16-Core-Laptop und teilten sich dessen CPU. Die Werte sind deshalb keine abstrakte Server-Garantie, sondern ein nachvollziehbarer Vergleich unter kontrollierten Bedingungen. Für die Beurteilung der relativen Verbesserung durch Sharding bleibt dieser Versuch dennoch aussagekräftig.

Datenmodell, Kompression und TTL-Verwaltung

Blobasaur unterstützt einfache Schlüssel sowie Redis-Hashes. Normale Werte werden in einer blobs-Tabelle gespeichert. Für Hashes existiert je Namespace eine eigene Tabelle wie blobs_prefs, damit HSET prefs user42 einem logisch getrennten Bereich zugeordnet wird. Beide Tabellentypen verwenden dieselben grundlegenden Spalten. Der Ablauf ähnelt einer Bibliothek mit nummerierten Fächern: Der Namespace bestimmt das Fach, und der konkrete Schlüssel bezeichnet den Eintrag darin.

Das Ablaufdatum liegt in derselben Zeile wie der Blob. Beim Lesen werden abgelaufene Datensätze ausgeschlossen. Ein Hintergrundprozess entfernt sie später, sodass Ablaufzeiten nicht erst durch einen synchronen Löschvorgang blockieren. Ein partieller Index auf expires_at erfasst nur Datensätze mit TTL. Einträge ohne Ablaufdatum verbrauchen darin keinen zusätzlichen Indexplatz.

Für Kompression unterstützt Blobasaur zstd, lz4, gzip und brotli. In der Produktion wird zstd eingesetzt. Messungen aus einer Stunde realem HSET-Traffic zeigten, dass durchschnittlich 63,6 KiB JSON nur 5,5 KiB benötigten, eine Reduktion um ungefähr das Elffache. Im p99-Fall sanken 935 KiB auf 59,3 KiB, also rund um den Faktor 16.

Der Platten- und Cache-Effekt ist unmittelbar relevant. Ein 63,6-KiB-Wert benötigt bei SQLite-Standardseiten von 4 KiB ungefähr 16 Seiten. Nach der Kompression sind es nur noch etwa zwei, noch ohne Zeilen- und Index-Overhead. Weniger Seiten bedeuten weniger Page-Cache-Druck, kleinere WAL-Schreibvorgänge und geringere I/O-Last. Kompression ist hier also kein nebensächlicher Bonus, sondern Teil des Speichermodells.

Pragmatische Haltbarkeit für nichtkritische Nutzerdaten

Blobasaur ist auf Daten ausgelegt, deren Verlust unkritisch wäre. Chart-Layouts, Oberflächenpräferenzen und Terminal-Konfigurationen beeinflussen die Bedienung einer Trading-Plattform, aber nicht die Ausführung von Finanztransaktionen. Ein kurzer Stromausfall, der die jüngsten Schreibvorgänge verliert, kann deshalb akzeptiert werden. Die Shards arbeiten im WAL-Modus mit PRAGMA synchronous = NORMAL. SQLite fsynct dabei nicht bei jedem Transaktionsabschluss.

Diese Entscheidung ist eng mit dem Datenrisiko verbunden. Eine entspannte Haltbarkeit wäre für protokollierte Transaktionen, Orderhistorie oder verbindliche Konfigurationen kaum vertretbar. Für vorübergehende Nutzeroberflächen eröffnet sie dagegen einen wirtschaftlichen und technischen Spielraum, der Blobasaur von einem universellen Datenbanksystem unterscheidet.

Auch die Auswahl der Schnittstelle folgt diesem Pragmatismus. Bestehende Go- und Python-Diensten sprachen bereits SSDB über das Redis-Protokoll an. Blobasaur übernimmt gängige Befehle wie GET, SET, HGET, HSET, DEL und EXPIRE. Dadurch konnten die Anwendungen weitgehend unverändert bleiben. Der Wechsel von einer Technologie wurde dadurch nicht zum erneuten Integrationsprojekt.

Das Projekt ist als Open Source verfügbar und läuft bei Zerodha produktiv. Es hat SSDB ersetzt. Diese Tatsache sagt mehr als eine synthetische Benchmark-Tabelle: Die Lösung muss nicht nur schnell sein, sondern auch mit Burst-Produktion, Wartung, Deployment und realen Datenmustern funktionieren.

Was das verteilte SQLite-Design konkret bedeutet

Blobasaur zeigt, dass SQLite weit mehr sein kann als eine lokale Beispieldatenbank. Das System nutzt ausgereizte Eigenschaften, die zu seinem Einsatz passen: WAL-Modus, Transaktionen, Crash-Recovery, SQL-Zugriff und kompakte lokale Dateien. Das Sharding löst die wichtigste strukturelle Schwäche, nämlich den einzelnen Writer, ohne SQLite in einen verteilten SQL-Cluster verwandeln zu müssen.

Die Lösung ist dennoch kein universeller Ersatz für S3, ScyllaDB oder eine klassische relationale Datenbank. Sie setzt moderate, burstartige Lasten voraus, akzeptiert einen begrenzten Verlust sehr junger Commits und priorisiert einfache Key-Value- und Hash-Zugriffe. Genau in diesem Rahmen erreicht sie eine bemerkenswerte Kombination aus Durchsatz, Latenz, Wartbarkeit und geringem Ressourcenbedarf.

Für die Praxis bleibt der wichtigste Grundsatz: Die passende Speicherarchitektur folgt nicht dem Datenbank-Namen, sondern dem konkreten Zugriffsmuster. Blobasaur ist dort überzeugend, wo Nutzerkonfigurationen als komprimierbare Blobs gespeichert, horizontal verteilt und ohne komplexe Anwendungslogik gelesen werden müssen. Es ist damit weniger ein Ersatz für beliebige Datenbanken als ein präzise gebautes Werkzeug für einen klar beschriebenen Job.

Quelle: zerodha.tech

Deine Reaktion:
Artikel teilen:
Krötzsch-Check0 — 100
Fakten 70
Relevanz 72
Hype 32
Einschätzung 65
Redaktion 50 Stand 50 · noch keine Stimmen
Ist das Hype?
Sebastian Krötzsch
Autor

Sebastian Krötzsch

Sebastian Krötzsch schreibt auf sebask.de über Künstliche Intelligenz, Automatisierung, digitale Systeme und die Frage, was davon im Alltag wirklich nützlich ist. Ohne Buzzword-Nebel, dafür mit klarem Blick auf Praxis, Tools und echte Wirkung.