Deze vergelijking richt zich op zelf-hostende Rust-native backends: sh0.dev, TrailBase en Aurabase. Voor een meer algemene, door uzelf gehoste backend, niet geschreven in Rust, verkennen onze vergelijkingen Aurabase versus PocketBase en Aurabase versus Appwrite andere opties. Voor de volledige analyse van wat “EU-soevereiniteit” juridisch betekent, hosting en nationaliteit van de uitgever, gaat ons artikel zelf-hosting versus een EU-soevereine BaaS verder; Dit bericht is beperkt tot het plaatsen van Aurabase onder zijn Rust-collega's.
De essentie
- Drie echte opties vandaag voor een zelf-hostende Rust-native backend: sh0.dev (enkel binair, ~25 MB), TrailBase (Rust + ingebedde SQLite + SolidJS-interface), Aurabase (volledig platform, speciale Postgres 16).
- Aurabase gaat uit van het tegenovergestelde compromis van een mono-binair bestand: meerdere georkestreerde diensten (k3d lokaal of Kubernetes/Helm in productie) in ruil voor multi-tenant RLS, real-time CDC en native AI (NL2SQL, RAG).
- Self-hosting en EU-soevereiniteit zijn twee verschillende assen: zelf hosten garandeert niets zolang de fysieke server en de uitgeverij zich zelf niet in de EU bevinden.
- Informatie over sh0.dev en TrailBase gebaseerd op hun openbare pagina's op het moment van schrijven, niet grondig gecontroleerd: controleer hun up-to-date documentatie voordat u beslissingen neemt.
Waarom ‘Rust-native’ belangrijk is voor zelfhosting
Een zelfgehoste backend verwijdert de infrastructuur uit de perimeter van een cloudprovider, maar niet de verantwoordelijkheid om deze betrouwbaar te laten draaien. Dit is waar de taalkeuze niet langer een detail is: de geheugenbeveiliging van Rust en het ontbreken van een garbage collector verminderen een hele reeks productiefouten, die het hardst worden getroffen door een klein team dat zijn eigen server beheert.
Dit is geen puur prestatieargument. Een service die geen segfouten kent en geen onvoorspelbare pauzes voor het verzamelen van geheugen heeft, is gemakkelijker te monitoren voor een team zonder een speciale SRE. De daadwerkelijke architectuur van de kern van Aurabase, de Cargo-werkruimte met 18 kratten, is in detail gedocumenteerd in ons Rust-architectuurbestand.
“Open source” alleen is niet voldoende om draagbaarheid of het ontbreken van lock-in te garanderen: de feitelijke architectuur, single-tenant of multi-tenant, propriëtaire of standaard opslagengine, is belangrijker. sh0.dev, TrailBase en Aurabase bieden allemaal toegang tot de broncode, maar met zeer verschillende scopes en datamodellen.
sh0.dev: een uniek Rust-binair bestand, ontworpen voor minimalisme
sh0.dev presenteert zichzelf, volgens de openbare pagina's op het moment van schrijven, als een backend die wordt gedistribueerd in de vorm van een enkel Rust-binair bestand van ongeveer 25 MB. Het centrale argument is de eenvoud van de implementatie: een bestand dat naar een server moet worden gekopieerd, zonder externe afhankelijkheden om afzonderlijk te installeren.
We hebben voor dit artikel de exacte functionele reikwijdte of het licentiemodel van sh0.dev niet in detail gecontroleerd: de openbaar beschikbare informatie over dit onderwerp blijft beperkt en een project van dit type evolueert snel. Als dit criterium een rol speelt bij uw beslissing, controleer dan de actuele officiële documentatie voordat u een beslissing neemt.
TrailBase: Roestkern, ingebedde SQLite, SolidJS-interface
TrailBase combineert, volgens de openbare pagina's, een backend-kern geschreven in Rust, een ingebedde SQLite-database en een beheerinterface gebouwd met SolidJS, allemaal geleverd als een zelfhostend project. De architectuur doet denken aan PocketBase (Go, SQLite, geïntegreerde interface), met een runtime geschreven in Rust in plaats van Go.
Net als bij sh0.dev beweert dit artikel niet dat het de TrailBase-code of routekaart grondig heeft gecontroleerd. Wat we met vertrouwen kunnen zeggen is de algemene architecturale positionering: een binair bestand dat zijn eigen opslagengine insluit in plaats van een backend die wordt ondersteund door een externe Postgres.
Aurabase: speciale Postgres 16, compleet platform, ook zelf gehost
Aurabase gaat uit van een andere afweging dan een monobinair bestand. De repository biedt een lokaal Kubernetes-cluster (k3d) dat in één opdracht wordt gelanceerd via ./start.sh, evenals een volledig Helm-diagram (deploy/helm/aurabase/) met afzonderlijke waardeprofielen voor Hetzner, een lokale Kubernetes-bank (k3d) en Scaleway. De root Cargo-werkruimte wordt vrijgegeven onder de MIT-licentie.
Deze keuze omvat verschillende te orkestreren diensten: gateway, authenticatie, database, realtime, opslag, functies, AI, in plaats van één enkel proces. In ruil daarvoor ontvangt elk project een speciaal PostgreSQL 16 (geen gedeeld SQLite-bestand), met pgvector 0.8.6 en pg_graphql ingebed in de tenantimage, en Row-Level Security-isolatie op engineniveau in plaats van op applicatieniveau.
De enige opmerkelijke nuance aan de Rust-kern: de standaardmodus voor edge-functies is afhankelijk van een speciale TypeScript-service (V8 Isolates), een technisch compromis dat in detail is gedocumenteerd in het hierboven aangehaalde architectuurbestand, en geen weglating die we liever stil houden.
Drie architecturen naast elkaar samengevat
De sh0.dev- en TrailBase-kolommen gemarkeerd met “controleren” weerspiegelen een niet-uitputtende zoektocht van onze kant naar deze twee tools, en niet een bevestigde afwezigheid van functionaliteit ervan.
| Criterium | Aurabase | sh0.dev | TrailBase |
|---|---|---|---|
| Hoofdtaal | Roest (volledige werkruimte, 18 kratten) | Roest (enkel binair getal) | Roest (kern) + SolidJS (interface) |
| Voetafdruk van implementatie | k3d lokaal of Helm/Kubernetes in productie, verschillende services | Enkel binair bestand, ~25 MB | Eén enkele binaire, ingebedde SQLite |
| Database | PostgreSQL 16 specifiek per project + pgvector + pg_graphql | Te verifiëren (officieel document) | Ingebouwde SQLite |
| Administratieve interface | Aparte Next.js-studio | Om te controleren | SolidJS-interface geïntegreerd in binair bestand |
| Native AI (NL2SQL / RAG) | Ja, ingecheckte code (aura-ai) | Om te controleren | Om te controleren |
| Officiële stem over deze vergelijking | Deze vergelijking, gepubliceerd door Aurabase | Geen, ongevraagd | Geen, ongevraagd |
EU-soevereiniteit: die niet afhankelijk is van de keuze voor een binair getal
Het zelf hosten van een backend geschreven in Rust, wat het ook mag zijn, garandeert op zichzelf niets met betrekking tot de soevereiniteit van de EU. Er moet aan twee verschillende voorwaarden worden voldaan: de fysieke server moet in de Europese Unie draaien en u moet er de feitelijke operationele controle over behouden. Noch sh0.dev, noch TrailBase, noch Aurabase kunnen de tweede voorwaarde voor u garanderen: u kiest waar u het binaire bestand of de containers wilt inzetten.
De jurisdictie van de software-uitgever is ook van belang, maar op een andere as: die van een versie die door de leverancier wordt beheerd en niet die van uw eigen self-hosting. Dit is de CLOUD Act-hoek die wordt beschreven in ons artikel over het kiezen van een BaaS. Voor de door Aurabase beheerde infrastructuur zelf: deze draait, geverifieerd in productie, op datacentra van Hetzner in Neurenberg en Falkenstein (Duitsland) en in Helsinki (Finland). Dit is de EU-soevereiniteit zoals die vandaag de dag bestaat, los van het Parijse hoofdkantoor van Aurabase SAS.
Details van de nalevingscriteria die u moet controleren voordat u een accommodatie kiest, soeverein of niet: onze pagina naleving.
Wanneer kies je wat
Als de footprint van de implementatie het belangrijkste criterium is, zijn een minimale VPS, een edge-apparaat, een project waarbij elke megabyte telt, sh0.dev of TrailBase het proberen waard. Dit zijn verdedigbare keuzes voor deze specifieke gebruikssituatie, ook al hebben we hun gedrag in de productie niet zelf getest.
Als uw project echte multi-tenancy nodig heeft met geavanceerde Row-Level Security, volledige Postgres in plaats van SQLite, of native AI (NL2SQL, RAG) zonder assemblage door derden, dan dekt Aurabase dat terrein. Het is ook het meest directe pad als je vertrekt vanuit een bestaand Supabase-project: Aurabase wordt dan gepositioneerd als een alternatief voor Supabase geschreven in Rust, met een SDK- en RLS-beleid dat streeft naar vrijwel directe compatibiliteit, gedocumenteerd in onze migratiehandleiding.