Aurabase Logo
aurabasedocs
docsFondationsArchitecture

Architecture

Huit services Axum indépendants, un réseau unifié via NATS, un cluster PostgreSQL par organisation. Comprenez comment Aurabase route une requête de bout en bout, comment chaque organisation puis chaque projet sont isolés, et comment scaler horizontalement sans coordination.

9 min de lecture·Niveau intermédiaire·Révisé le 15 avr. 2026
#
Vue d’ensemble

Un backend, huit services, un réseau

Aurabase est un monorepo Rust organisé en 8 binaires Axum indépendants. Chacun écoute sur son propre port, expose ses routes HTTP /v1/<service>/…, et communique avec les autres via NATS request/reply.

Un service peut redémarrer, crash ou être déployé indépendamment. Le gateway observe la santé de chacun via un circuit breaker — après 5 échecs consécutifs sur un service, il ouvre le disjoncteur et répond 503 pendant 30 secondes, laissant le service récupérer.

Info
L'ensemble de la plateforme est open-source sous licence Apache 2.0 et disponible sur GitHub sur le dépôt officiel Aurabase.
#
Les 8 services

Rôles et responsabilités

Chaque microservice a une responsabilité unique, des migrations SQL dédiées et un cloisonnement strict. Tout le trafic externe passe exclusivement par la passerelle unifiée.

ServiceRôleResponsabilités
aura-gatewayPasserelle APIProxy, middleware d’authentification, rate limiting, circuit breaker
aura-authAuthentificationSignup, signin, OAuth 2.1, MFA TOTP & WebAuthn, sessions, JWKS
aura-dbBase de donnéesCRUD PostgREST, migrations versionnées, codegen, gestion de schéma
aura-realtimeMoteur Temps-RéelWebSocket binaire, SSE, relais d’événements, présence, CDC Postgres
aura-storageStockage d’objetsBackend S3-compatible, upload multipart, URLs signées, transformations
aura-functionsEdge FunctionsRuntime WASM/Deno, cron périodique, file de jobs asynchrones, DLQ
aura-notificationsNotificationsEmail transactionnel (SMTP), SMS, push mobile, webhooks signés HMAC
aura-aiPasserelle IAInférence LLM unifiée, calcul d’embeddings vectoriels, RAG pgvector
Astuce
Architecture modulaire : Les microservices partagent des contrats de données stricts et des primitives de sécurité unifiées (chiffrement de bout en bout, JWT ES256, RLS).
#
Modèle mental

Un cluster CNPG par organisation, un projet, quatre schémas

Chaque organisation Aurabase reçoit son propre cluster PostgreSQL, provisionné via CloudNativePG (CNPG) dans un namespace Kubernetes qui lui est réservé — jamais partagé avec une autre organisation. Sa capacité (vCPU, mémoire, réplicas) grandit avec le palier de plan de l'organisation (Free → Pro → Team).

À l'intérieur de ce cluster, chaque projet reçoit sa propre base de données Postgres, elle-même divisée en quatre sous-schémas. Le cloisonnement inter-projets y est appliqué par PostgreSQL lui-même : chaque projet possède son propre rôle de connexion, membre de ses seuls rôles, et les droits sur ses schémas ne sont accordés qu'à ceux-là — jamais à PUBLIC. Le gateway injecte le search_path de connexion à partir du JWT du client, et les tables applicatives sont protégées par RLS.

Sur l'offre enterprise, un projet peut en plus recevoir un cluster CNPG entièrement dédié, réservé à lui seul dans son propre namespace : le cloisonnement y est alors assuré par la séparation physique des clusters, pas seulement par les permissions et l'isolation logique du namespace partagé.

SchémaPropriétaireContenu
project_{uuid}userVos tables métier
project_{uuid}_authaura-authusers, sessions, oauth_accounts, mfa
project_{uuid}_storageaura-storagebuckets, objects, rls_policies
project_{uuid}_platformplateformefunctions, jobs, cron, api_keys, webhooks

Trois garanties

  • Isolation par organisation — aucun cluster, namespace Kubernetes ou pool de connexions n'est jamais partagé entre deux organisations différentes : pas de fuite cross-tenant, pas de voisin bruyant venu d'un autre client.
  • Migrations indépendantes — chaque projet évolue à son rythme ; un rollback n'affecte que lui.
  • Export trivial pg_dump --schema=project_* rend toute votre base, extensions et policies incluses.
Attention
Exception : le schéma aura_console est partagé. Il contient la table projects et les sessions Studio globales. Aucune donnée applicative n'y transite.
#
Flux d’une requête

De curl à Postgres, en sept étapes

Le gateway valide chaque requête entrante avant de la router. Voici le chemin complet d'un GET /v1/db/{projectId}/rows?table=devices depuis un client REST.

flux.log
TEXT
# 1. Terminaison HTTPS & Passerelle API
Client HTTPS → aura-gateway (/v1/db/devices)
# 2. Middleware request_id + tracing
request_id = "req_7f3c..." trace_id = "4a2e..."
# 3. Rate limit (token bucket par IP + clé API)
RATE_LIMIT_RPS=100 burst=200
# 4. Authentification — Décodage JWT + vérification des claims
Auth Middleware → { sub: "u_9k2", project_id: "p_a7f3", role: "authenticated" }
# 5. Circuit breaker — Dispatch vers le service de données
circuit_breaker[aura-db] = HEALTHY proceed
# 6. Exécution PostgreSQL avec isolation de schéma et RLS
SET search_path TO project_a7f3_, public;
SELECT id, value FROM devices ORDER BY last_seen DESC LIMIT 50;
Astuce
Observabilité baked-in. Chaque étape logge structuré via tracing + EnvFilter. Les logs JSON sont corrélés par request_id et peuvent être exportés vers Datadog, Honeycomb ou votre SIEM via webhook.
#
Scale horizontal

Ajouter de la capacité, pas de la coordination

Les services sont sans état. Ajouter un réplica signifie démarrer un nouveau binaire et le connecter à NATS — il se rejoint le cluster automatiquement et commence à servir dès qu'il est prêt. Aucun leader, aucune élection, aucune coordination distribuée.

GATEWAY
1M req/s
Anycast BGP + load balancer L7
DB
96 vCPU
Vertical scale up à la demande
REALTIME
1M cnx/POP
Fan-out via NATS JetStream
FUNCTIONS
2.4M/jour
WASM isolated, memory-safe
Dernière mise à jour · 15 avr. 2026