Benchmarking Real-Time Database Synchronisation Architectures: REST Polling, WebSocket Push, and CockroachDB CDC
Dit artikel presenteert een gecontroleerde benchmark die REST-polling, WebSocket-push en CockroachDB CDC-architecturen vergelijkt voor real-time databasesynchronisatie, waarbij wordt onthuld dat hoewel WebSocket-push de laagste mediane latentie biedt en REST-polling voorspelbare begrensde vertragingen oplevert, CDC concurrerende medianen levert maar lijdt onder significante tail-latentie door batching en specifieke protocolincompatibiliteiten.
Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer
In de wereld van moderne software is er een groeiende verlangen naar applicaties die aanvoelen alsof ze op je apparaat leven, zelfs wanneer je niet verbonden bent met het internet. Deze aanpak, vaak lokale-eerst-software genoemd, stelt je in staat om een document te bewerken of een lijst bij te werken terwijl je offline bent, waarbij de wijzigingen wachten om naar een centrale server te worden verzonden zodra je verbinding wordt hersteld. De uitdaging ligt op het moment dat de verbinding wordt hersteld: hoe beslist de computer welke versie van de gegevens correct is, en hoe snel kan het de centrale server bijwerken zonder dat de gebruiker hoeft te wachten? Om dit soepel te laten verlopen, heeft het systeem een betrouwbare manier nodig om nieuwe informatie te beluisteren en deze direct te leveren. Als de update te traag is, voelt de gebruiker een vertraging; als het systeem te complex is, put het de batterij uit of crasht het. De kernvraag voor ingenieurs is hoe ze dit luistermechanisme moeten bouwen: moet het apparaat constant aan de server vragen of er iets is veranderd, moet de server de wijzigingen onmiddellijk naar buiten roepen, of moet de database zelf een voortlopend logboek bijhouden van elke actie om later te lezen?
Een onderzoeker aan het Indian Institute of Technology Kharagpur begon te testen hoe deze drie veelvoorkomende strategieën zij aan zij presteren om te zien welke er in een gecontroleerde omgeving daadwerkelijk het beste werkt. De studie vergeleek een methode waarbij de client op vaste intervallen controleert op updates, een methode waarbij de server wijzigingen onmiddellijk doorgeeft via een permanente verbinding, en een methode waarbij de database een logboek van elke wijziging naar abonnees streamt. Om een eerlijke test te garanderen, bouwde de onderzoeker drie aparte systemen die voor de gebruiker identiek leken, maar verschillende interne tandwielen gebruikten. Eén systeem gebruikte een standaard database met een eenvoudige "check-in"-lus. Een ander systeem gebruikte dezelfde database, maar voegde een trigger toe die een signaal afvuurde op het moment dat een wijziging plaatsvond. Het derde systeem gebruikte een andere, gedistribueerde database die ontworpen is om zijn eigen geschiedenis te streamen. Het doel was om de exacte tijd te meten die een wijziging gemaakt door een gebruiker nodig had om door het systeem te reizen en op het scherm van de luisteraar te verschijnen, waarbij werd getest van een enkele gebruiker tot vijftig gebruikers die tegelijkertijd schreven.
De resultaten schetsen een duidelijk beeld van hoe elke methode onder druk reageert. Het systeem dat vertrouwde op de server die wijzigingen onmiddellijk doorgeeft via een permanente verbinding, bleek de snelste te zijn. In de beste gevallen verscheen een wijziging op het scherm van de luisteraar in slechts twee milliseconden, en zelfs wanneer vijftig mensen tegelijkertijd schreven, overschreed de vertraging zelden drieënzestig milliseconden. Deze methode hield de snelheid opmerkelijk stabiel, waarbij zelfs de traagste updates in minder dan een kwart seconde arriveerden. De methode die vertrouwde op de client die elke honderd milliseconden om updates vraagt, was voorspelbaar maar langzamer. Omdat de client moest wachten op zijn beurt om te vragen, was de gemiddelde vertraging ongeveer zestig milliseconden, maar het kon nooit sneller zijn dan de tijd tussen de controles. Wanneer veel gebruikers tegelijkertijd schreven, nam deze wachttijd toe, waardoor de gemiddelde vertraging boven de honderd milliseconden uitkwam. Het systeem dat het interne logboek van wijzigingen van de database gebruikte, vertoonde een gemengde prestatie. Hoewel de typische update snel arriveerde, vaak in minder dan een seconde, leed het systeem onder ernstige vertragingen voor de traagste enkelingen. Geleidelijk tijdens kwam een wijziging soms meer dan twee seconden na, en in sommige gevallen liep de vertraging op tot meer dan drieënhalf seconde.
De onderzoeker ontdekte dat de traagste updates in het loggebaseerde systeem niet een fout waren in het idee van het loggen van wijzigingen zelf, maar een gevolg van hoe de specifieke software was verbonden. Het systeem gebruikte een workaround om het database-logboek te lezen omdat de standaard verbindingsmethode de taal van de database niet correct sprak. Deze workaround vereiste het starten van een nieuw proces telkens wanneer de verbinding werd onderbroken, wat een zware straf van één tot vier seconden aan de vertraging toevoegde. Zonder deze specifieke technische hindernis zou de loggebaseerde methode veel beter gepresteerd kunnen hebben, maar in deze test maakten de lange vertragingen het ongeschikt voor applicaties waar gebruikers directe feedback verwachten. De studie bevestigde ook een eenvoudige regel voor de controle-methode: hoe langer men wacht tussen de controles, hoe langer de gemiddelde vertraging wordt. Als een systeem elke vijftig milliseconden controleert, is de gemiddelde wacwart ongeveer zesendertig milliseconden; als het vijf honderd milliseconden tussen de controles wacht, springt de gemiddelde wachttijd naar meer dan driehonderd milliseconden.
Deze bevindingen bieden een praktische gids voor het bouwen van software die synchroon moet blijven. Voor applicaties waar snelheid cruciaal is, zoals collaboratieve bewerkingsinstrumenten waarbij gebruikers in realtime samen typen, is de methode waarbij de server wijzigingen onmiddellijk doorgeeft de duidelijke keuze. Het biedt de laagste vertraging en de meest consistente prestaties, zelfs wanneer veel mensen het systeem tegelijkertijd gebruiken. De methode waarbij de client op regelmatige intervallen naar updates vraagt, is een solide optie voor eenvoudigere applicaties waar een vertraging van enkele honderden milliseconden acceptabel is, of waar het openhouden van de verbinding moeilijk is, zoals op mobiele apparaten die batterij willen besparen. De methode die het database-logboek streamt, is krachtig voor het verplaatsen van grote hoeveelheden gegevens of het maken van back-ups, maar de specifieke implementatie die hier werd getest, was te traag en onvoorspelbaar voor interactief gebruik. De studie concludeert dat hoewel alle drie de methoden werken, de beste keuze volledig afhangt van de vraag of de prioriteit ligt bij directe responsiviteit of operationele eenvoud.
Verdrinkt u in papers in uw vakgebied?
Ontvang dagelijkse digests van de nieuwste papers die bij uw onderzoekswoorden passen — met technische samenvattingen, in uw taal.