Architecture Hybride : Le Meilleur des Deux Mondes avec Supabase et Spring Boot

Опубликовано 14 January 2026

время чтения : 12 minutes

Вместо того чтобы выбирать между простотой Supabase и мощью Spring Boot, почему бы не объединить их? Узнайте о гибридной архитектуре, которая использует лучшее от каждой технологии.

Table of Contents

Ложная дилемма современной архитектуры

Когда мы создаём современное приложение со статическим фронтендом, мы часто сталкиваемся с бинарным выбором:

  • Ставь всё на решение Backend-as-a-Service(Supabase, Firebase) - простая, но ограниченная

  • Создать полностью готовый бэкенд(Spring Boot, Node.js) - мощный, но сложный

Это выбор — ложная дилемма. Гибридная архитектура предлагает третий путь: использовать каждую технологию там, где она преуспевает.

Архитектурное видение

Традиционная архитектура: монолитная

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

package "Architecture Traditionnelle" {
  actor Utilisateur as user
  component "Frontend" as frontend #LightBlue
  component "Backend Monolithique" as backend #LightCoral {
    [Authentification]
    [CRUD]
    [Logique Métier]
    [Jobs]
    [APIs Tierces]
  }
  database "Base de Données" as db #LightGray

  user --> frontend
  frontend --> backend : Toutes les requêtes
  backend --> db
}

note right of backend
  Tout passe par le backend
  même les opérations simples

  ⚠️ Point de congestion unique
  ⚠️ Complexité dès le départ
  ⚠️ Couplage fort
end note
@enduml

В этом подходе даже самые простые операции (чтение статьи, создание комментария) должны проходить через ваш бекенд. Вы платите за сложность уже с первого дня.

Архитектура BaaS: Все делегаты

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

package "Architecture BaaS Pure" {
  actor Utilisateur as user
  component "Frontend" as frontend #LightBlue
  cloud "Supabase / Firebase" as baas #LightGreen {
    [Auth]
    [Database]
    [Storage]
    [Edge Functions]
  }

  user --> frontend
  frontend --> baas : Toutes les opérations
}

note right of baas
  Développement rapide
  Pas de serveur à gérer

  ⚠️ Limité pour logique complexe
  ⚠️ Vendor lock-in
  ⚠️ Edge Functions contraintes
end note
@enduml

Напротив, делегировать всё в BaaS кажется привлекательным вначале, но быстро показывает свои ограничения, когда бизнес-логика усложняется.

Гибридная архитектура: разделение ответственности

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

actor Utilisateur as user #LightBlue

package "Couche Frontend" {
  component "Site Statique JBake" as frontend #SkyBlue
}

package "Couche Simple (Supabase)" #LightGreen {
  component "Authentification" as auth
  component "CRUD Basique" as crud
  component "Stockage Fichiers" as storage
  component "Temps Réel" as realtime
}

package "Couche Métier (Spring Boot)" #Coral {
  component "Logique Complexe" as logic
  component "Orchestration" as orchestration
  component "Jobs Planifiés" as jobs
  component "Intégrations" as integrations
}

database "PostgreSQL Partagé" as db #LightGray

user --> frontend

frontend --> auth : OAuth2, JWT
frontend --> crud : Articles, Profils
frontend --> storage : Images, Fichiers
frontend --> realtime : Notifications

frontend --> logic : Calculs, Rapports
frontend --> orchestration : Workflows
logic --> integrations : Stripe, APIs
orchestration --> db
jobs --> db

crud --> db
auth --> db

note bottom of db
  **Une seule source de vérité**
  Partagée entre Supabase et Spring Boot
end note

note right of auth
  **Gratuit jusqu'à 50k users**
  Configuration en quelques clics
  OAuth2 multi-providers
end note

note right of logic
  **Activé seulement si nécessaire**
  Kotlin + Coroutines
  Transactions complexes
end note
@enduml

Гибридная архитектура четко разделяет ответственность в зависимости от сложности и характера операций.

Принципы проектирования

Принцип 1: Начать просто, развиваться умно

@startuml
skinparam backgroundColor #FEFEFE

rectangle "**Phase 1 : MVP**" #LightGreen {
  component "JBake + Supabase" as mvp
  note right
    ✓ Développement en jours
    ✓ Coût : 0€
    ✓ Validation concept
  end note
}

rectangle "**Phase 2 : Croissance**" #LightYellow {
  component "JBake + Supabase\n+ Spring Boot (optionnel)" as growth
  note right
    ✓ Logique métier émerge
    ✓ Premiers jobs planifiés
    ✓ Intégrations tierces
  end note
}

rectangle "**Phase 3 : Scale**" #LightCoral {
  component "Architecture Complète" as scale
  note right
    ✓ Orchestration complexe
    ✓ Performances optimisées
    ✓ Cache distribué
  end note
}

mvp -down-> growth : Quand la complexité\nle justifie
growth -down-> scale : Optimisation\ncontinue
@enduml

Не создавайте Spring Boot, если вам это не нужно.Начните работу с Supabase, добавьте Spring Boot, когда это оправдано сложностью.

Принцип 2: Разделение по характеру операции

@startmindmap
skinparam backgroundColor #FEFEFE
* Opérations\nApplicatives

left side

** Opérations Simples\n(Supabase)
***_ CRUD Standard
****_ Lecture
****_ Création
****_ Mise à jour
****_ Suppression
***_ Authentification
****_ Login/Logout
****_ OAuth2
****_ Gestion session
***_ Stockage
****_ Upload fichiers
****_ CDN automatique
***_ Temps Réel
****_ WebSocket
****_ Notifications

right side

** Opérations Complexes\n(Spring Boot)
***_ Logique Métier
****_ Calculs complexes
****_ Règles métier
****_ Validations avancées
***_ Orchestration
****_ Multi-services
****_ Transactions distribuées
****_ Saga patterns
***_ Tâches Planifiées
****_ Rapports périodiques
****_ Synchronisations
****_ Nettoyages
***_ Intégrations
****_ Paiements (Stripe)
****_ APIs tierces
****_ Services ML/AI

@endmindmap

Принцип 3: Единственный источник истины

@startuml
skinparam backgroundColor #FEFEFE

database "PostgreSQL" as db #LightGray {
  package "Схема: auth (Supabase)" #LightGreen {
    [users]
    [sessions]
    [identities]
  }

  package "Схема: public (Общая)" #SkyBlue {
    [articles]
    [comments]
    [profiles]
  }

  package "Схема: business (Spring Boot)" #Coral {
    [orders]
    [payments]
    [reports]
  }
}

component "Supabase" as supabase #LightGreen
component "Spring Boot" as spring #Coral

supabase -down-> users : Gère
supabase -down-> sessions : Gère
supabase -down-> articles : Accède
supabase -down-> comments : Accède
supabase -down-> profiles : Accède

spring -down-> articles : Accède
spring -down-> profiles : Accède
spring -down-> orders : Gère
spring -down-> payments : Gère
spring -down-> reports : Gère

note right of db
**Преимущества:**
• Отсутствие сложной синхронизации
• Возможность использования JOIN между таблицами
• Гарантированная согласованность
• Унифицированные миграции
end note
@enduml

Разделяя один и тот же экземпляр PostgreSQL, Supabase и Spring Boot работают с одними и теми же данными без сложной синхронизации.

Оркестрирование потоков

Flux 1 : централизованная аутентификация

@startuml
skinparam backgroundColor #FEFEFE
autonumber

actor "Utilisateur" as user
participant "JBake" as jbake
participant "Supabase Auth" as auth
participant "Spring Boot" as spring
database "PostgreSQL" as db

== Authentification ==
user -> jbake : Clique "Se connecter"
jbake -> auth : Redirect OAuth2 (Google/GitHub)
auth -> user : Consent screen
user -> auth : Autorise
auth -> auth : Génère JWT
auth -> jbake : Retourne JWT + Refresh Token
jbake -> jbake : Stocke tokens (sessionStorage)

== Accès aux Ressources ==
group Opération Simple (CRUD)
  user -> jbake : Crée un article
  jbake -> db : POST avec JWT
  note right: Supabase Row Level Security\nvérifie le JWT automatiquement
  db -> jbake : Article créé
end

group Opération Complexe (Métier)
  user -> jbake : Génère un rapport
  jbake -> spring : POST /api/reports\navec JWT
  spring -> spring : Valide JWT Supabase
  spring -> spring : Extrait claims (user_id, roles)
  spring -> db : Requêtes complexes
  spring -> jbake : Rapport généré
end

note over auth, spring
  **Le JWT est universel**
  Valide par Supabase ET Spring Boot
  Pas de double authentification
end note
@enduml

Ключевой пункт: Один процесс аутентификации, один JWT, пригодный для использования везде.

Поток 2: Оркестровка сложного бизнес-процесса

@startuml
skinparam backgroundColor #FEFEFE
autonumber

actor "Client" as user
participant "JBake" as jbake
participant "Spring Boot" as spring
participant "Supabase DB" as supadb
participant "Stripe API" as stripe
participant "Inventory Service" as inventory
participant "Email Service" as email
database "PostgreSQL" as db

user -> jbake : Passe commande
jbake -> spring : POST /api/orders/create

== Orchestration Spring Boot ==
spring -> db : BEGIN TRANSACTION

par Vérifications Parallèles
  spring -> inventory : Vérifier stock
  inventory -> spring : Stock OK
else
  spring -> db : Vérifier profil client
  db -> spring : Client vérifié
end

spring -> stripe : Créer Payment Intent
stripe -> spring : Intent créé (ID: pi_xxx)

spring -> db : Créer Order (status: PENDING)
db -> spring : Order créé

spring -> stripe : Confirmer paiement
stripe -> spring : Paiement confirmé

spring -> db : Update Order (status: PAID)
spring -> inventory : Décrémenter stock
spring -> db : COMMIT TRANSACTION

par Notifications Asynchrones
  spring -> email : Email confirmation
else
  spring -> supadb : Insert notification
  note right: Notification temps réel\nvia Supabase Realtime
end

spring -> jbake : Order confirmé
jbake -> user : Affiche confirmation

note over spring
  **Responsabilités Spring Boot :**
  • Transaction ACID
  • Orchestration multi-services
  • Rollback automatique si erreur
  • Gestion des cas limites
end note
@enduml

Что приносит Spring Boot: Надёжная оркестровка сложных процессов, вовлекающих несколько систем, с транзакционной гарантией.

Flux 3: Запланированные задачи и синхронизации

@startuml
skinparam backgroundColor #FEFEFE

participant "Scheduler\n(Spring Boot)" as scheduler
participant "Report Service" as report
participant "PostgreSQL" as db
participant "External API" as api
participant "Email Service" as email
participant "Supabase Storage" as storage

== Job Quotidien : 2h00 ==
activate scheduler
scheduler -> report : Déclenche génération rapport

activate report
report -> db : Récupère données\ndes dernières 24h
db -> report : Dataset

report -> report : Calculs & Agrégations
report -> report : Génération PDF

report -> storage : Upload PDF
storage -> report : URL publique

report -> email : Envoie aux admins\navec lien PDF
deactivate report

== Job Hebdomadaire : Dimanche 3h00 ==
scheduler -> report : Synchronisation externe

activate report
report -> api : Fetch données externes
api -> report : Nouvelles données

report -> db : Mise à jour tables
report -> db : Nettoyage données obsolètes
deactivate report

== Job Mensuel : 1er du mois ==
scheduler -> report : Facturation

activate report
report -> db : Liste clients actifs
report -> report : Calcul montants
report -> api : Génération factures (Stripe)
report -> email : Envoi factures
deactivate report

deactivate scheduler

note right of scheduler
  **Impossible avec Supabase seul**
  Edge Functions non adaptées
  pour jobs longs et récurrents
end note
@enduml

Что приносит Spring Boot: Надёжные запланированные задачи с управлением состоянием, автоматическим повтором и гарантированным выполнением.

Матрица принятия решений

Когда использовать Supabase?

@startuml
skinparam backgroundColor #FEFEFE

start

:Nouvelle fonctionnalité à implémenter;

if (CRUD simple ?) then (oui)
  :✅ **Supabase**;
  stop
else (non)
  if (Authentification ?) then (oui)
    :✅ **Supabase Auth**;
    stop
  else (non)
    if (Upload fichiers ?) then (oui)
      :✅ **Supabase Storage**;
      stop
    else (non)
      if (Temps réel ?) then (oui)
        :✅ **Supabase Realtime**;
        stop
      else (non)
        if (Row Level Security\nsuffisante ?) then (oui)
          :✅ **Supabase + Policies**;
          stop
        else (non)
          :⚠️ **Considérer Spring Boot**;
          #Coral:Passer à l'arbre\nde décision Spring Boot;
          stop
        endif
      endif
    endif
  endif
endif

@enduml

Когда использовать Spring Boot?

@startuml
skinparam backgroundColor #FEFEFE

start

:Nouvelle fonctionnalité complexe;

if (Orchestration\nmulti-services ?) then (oui)
  :✅ **Spring Boot**;
  stop
else (non)
  if (Transaction ACID\ncritique ?) then (oui)
    :✅ **Spring Boot**;
    stop
  else (non)
    if (Job planifié ?) then (oui)
      :✅ **Spring Boot Scheduler**;
      stop
    else (non)
      if (Intégration API\ntierce complexe ?) then (oui)
        :✅ **Spring Boot**;
        stop
      else (non)
        if (Calculs lourds\n> 10 secondes ?) then (oui)
          :✅ **Spring Boot**;
          stop
        else (non)
          if (Cache distribué\nnécessaire ?) then (oui)
            :✅ **Spring Boot + Redis**;
            stop
          else (non)
            :⚠️ **Probablement Supabase**;
            #LightGreen:Revenir à l'arbre\nde décision Supabase;
            stop
          endif
        endif
      endif
    endif
  endif
endif

@enduml

Примеры архитектуры по типу проекта

Блог / Портфолио

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

package "Персонал блога — 95% Supabase" {
  component "JBake" as jbake #SkyBlue

  package "Supabase (Бесплатно)" #LightGreen {
    [Auth: OAuth2 Google]
    [Articles (CRUD)]
    [Commentaires]
    [Images (Storage)]
    [Notifications Realtime]
  }

  package "Spring Boot (Опционально)" #LightCoral {
    [Newsletter Mensuelle]
    note bottom: Только запланированное задание
  }

  database "PostgreSQL" as db

  jbake --> [Auth: OAuth2 Google]
  jbake --> [Articles (CRUD)]
  jbake --> [Commentaires]
  jbake --> [Images (Storage)]
  jbake --> [Notifications Realtime]

  [Articles (CRUD)] --> db
  [Commentaires] --> db
  [Newsletter Mensuelle] --> db
}

note bottom of "Spring Boot (Опционально)"
**Spring Boot не обязателен**
Рассылка может управляться
сторонним сервисом (Mailchimp)
end note
@enduml

Вердикт: 100% Supabase более чем достаточно.

приложение SaaS

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

package "SaaS-приложение — Гибридная архитектура" {
  component "JBake / React" as frontend #SkyBlue

  package "Supabase" #LightGreen {
    [Auth Multi-tenant]
    [Profils Utilisateurs]
    [Données Simples]
    [Storage Documents]
  }

  package "Spring Boot" #Coral {
    [Facturation (Stripe)]
    [Analytics Avancées]
    [Rapports Mensuels]
    [Quotas & Limites]
    [Webhooks Stripe]
  }

  cloud "Внешние сервисы" {
    [Stripe API]
    [SendGrid Email]
  }

  database "Общий PostgreSQL" as db

  frontend --> [Auth Multi-tenant]
  frontend --> [Profils Utilisateurs]
  frontend --> [Données Simples]
  frontend --> [Facturation (Stripe)]
  frontend --> [Analytics Avancées]

  [Auth Multi-tenant] --> db
  [Profils Utilisateurs] --> db
  [Données Simples] --> db

  [Facturation (Stripe)] --> db
  [Facturation (Stripe)] --> [Stripe API]
  [Analytics Avancées] --> db
  [Rapports Mensuels] --> db
  [Rapports Mensuels] --> [SendGrid Email]
  [Webhooks Stripe] ..> [Stripe API] : Écoute
}

note right of "Spring Boot"
**Необходимо для:**
• Управления подписками
• Рекуррентного биллинга
• Динамических квот
• Сложной аналитики
• Надежных вебхуков
end note
@enduml

приговор: Необходима гибридная архитектура. Supabase для основного, Spring Boot для критической части (платежи, выставление счетов).

Электронная коммерция

@startuml
skinparam backgroundColor #FEFEFE
skinparam componentStyle rectangle

package "Электронная коммерция - 70% Spring Boot" {
  component "Storefront (JBake/React)" as frontend #SkyBlue

  package "Supabase" #LightGreen {
    [Auth Clients]
    [Catalogue Produits\n(lecture seule)]
    [Images Produits]
  }

  package "Spring Boot (Бизнес-логика)" #Coral {
    [Gestion Commandes]
    [Paiements Stripe]
    [Gestion Stock]
    [Calcul Frais Port]
    [Génération Factures]
    [Synchronisation ERP]
    [Emails Transactionnels]
  }

  cloud "Интеграции" {
    [Stripe]
    [Transporteur API]
    [ERP Externe]
  }

  database "PostgreSQL" as db

  frontend --> [Auth Clients]
  frontend --> [Catalogue Produits\n(lecture seule)]
  frontend --> [Gestion Commandes]

  [Auth Clients] --> db
  [Catalogue Produits\n(lecture seule)] --> db

  [Gestion Commandes] --> db
  [Paiements Stripe] --> [Stripe]
  [Gestion Stock] --> db
  [Calcul Frais Port] --> [Transporteur API]
  [Génération Factures] --> db
  [Synchronisation ERP] --> [ERP Externe]
  [Synchronisation ERP] --> db
}

note right of "Spring Boot (Бизнес-логика)"
**Spring Boot незаменим при:**
• Критических транзакциях
• Сложной оркестрации
• Множественных интеграциях
• Соответствии законодательству
• Заданиях по синхронизации
end note
@enduml

Вердикт: Spring Boot необходим. Supabase только для аутентификации и каталога.

Стратегия постепенной миграции

@startuml
skinparam backgroundColor #FEFEFE

|Semaine 1-2|
start
:Créer projet Supabase;
:Configurer Auth (Google, GitHub);
:Définir schéma PostgreSQL initial;
:Implémenter CRUD de base sur JBake;
:Déployer MVP sur GitHub Pages;
note right
  **Livrable :** Application fonctionnelle
  **Coût :** 0€
  **Temps :** 1-2 semaines
end note

|Semaine 3-4|
:Observer utilisation réelle;
:Identifier limitations;

|Décision|
if (Logique complexe\némerge ?) then (non)
  |Supabase|
  :Continuer avec Supabase seul;
  :Ajouter Edge Functions si besoin;
  stop
else (oui)
  |Spring Boot|
  :Créer projet Spring Boot;
  :Configurer validation JWT Supabase;
  :Migrer logique complexe vers Spring Boot;
  note right
    **Migration sélective**
    Seulement ce qui est complexe
  end note
endif

|Semaines suivantes|
:Déployer Spring Boot (Cloud Run, EC2);
:Connecter à PostgreSQL Supabase;
:Implémenter premiers jobs planifiés;
:Intégrer APIs tierces;

stop

note right
  **Architecture finale hybride**
  Supabase + Spring Boot
  en parfaite harmonie
end note
@enduml

Стоимость и операционные соображения

Структура затрат

@startuml
skinparam backgroundColor #FEFEFE

package "Ориентировочные ежемесячные затраты" {

  rectangle "Фаза MVP\n(0-1000 пользователей)" #LightGreen {
    [JBake (GitHub Pages): 0€]
    [Supabase: 0€]
    [Spring Boot: N/A]
    note bottom: **Итого: 0€/мес**
  }

  rectangle "Фаза роста\n(1k-10k пользователей)" #LightYellow {
    [JBake (GitHub Pages): 0€]
    [Supabase: 0€]
    [Spring Boot (Cloud Run): 20-50€]
    [PostgreSQL (si séparé): 0-30€]
    note bottom: **Итого: 20-80€/мес**
  }

  rectangle "Фаза масштабирования\n(10k-100k пользователей)" #LightCoral {
    [JBake (Netlify Pro): 19€]
    [Supabase Pro: 25€]
    [Spring Boot (instances multiples): 100-300€]
    [Redis Cache: 20-50€]
    [Monitoring: 20€]
    note bottom: **Итого: 184-414€/мес**
  }
}

note right of "Фаза масштабирования\n(10k-100k пользователей)"
На данном этапе доходы с лихвой оправдывают затраты
end note
@enduml

Операционные обязанности

@startuml
skinparam backgroundColor #FEFEFE

package "Кто чем управляет?" {

  rectangle "Управляется Supabase (0 усилий)" #LightGreen {
    [Authentification]
    [Base de données]
    [Backups automatiques]
    [Scaling automatique]
    [Monitoring DB]
    [Sécurité DB]
  }

  rectangle "Управляется GitHub (0 усилий)" #SkyBlue {
    [Hébergement site statique]
    [HTTPS/SSL]
    [CDN global]
    [Déploiement automatique]
  }

  rectangle "Требует управления (Spring Boot)" #LightCoral {
    [Déploiement application]
    [Monitoring APM]
    [Logs centralisés]
    [Scaling horizontal]
    [Mises à jour sécurité]
  }
}

note bottom of "Требует управления (Spring Boot)"
**Минимизируется с помощью:**
• Cloud Run (serverless)
• Kubernetes (при необходимости)
• Управляемых сервисов (RDS и т. д.)
end note
@enduml

Conclusion : Идеальное равновесие

Гибридная архитектура Supabase + Spring Boot не является компромиссом, этосинергия.

Принципы, которые следует запомнить

@startmindmap
skinparam backgroundColor #FEFEFE
* Architecture\nHybride

** Commencer Simple
***_ MVP avec Supabase
***_ 0€ de coût initial
***_ Validation rapide

** Évoluer Intelligemment
***_ Ajouter Spring Boot\nsi nécessaire
***_ Migration progressive
***_ Pas de refonte totale

** Exploiter les Forces
***_ Supabase: Simplicité
***_ Spring Boot: Puissance
***_ PostgreSQL: Source unique

** Minimiser la Complexité
***_ Pas de synchronisation
***_ Pas de duplication
***_ Architecture claire

** Optimiser les Coûts
***_ Gratuit au départ
***_ Scaling progressif
***_ ROI évident

@endmindmap

Когда стоит выбрать эту архитектуру?

✅ Эта архитектура идеальна, если :

  • Вы хотите быстро начать (MVP за дни, а не за месяцы)

  • Вы ожидаете роста сложности бизнеса

  • Вы хотите минимизировать начальные расходы

  • Вы любите PostgreSQL и хотите единственный источник истины

  • Вы цените Kotlin и корутины для бизнес-кода

  • Вы хотите избежать полной привязки к поставщику

❌ Эта архитектура НЕ подходит если:

  • Ваш проект прост и останется простым (личный блог → 100% Supabase достаточно)

  • У вас уже есть сложившийся бэкенд-стек, которым вы владеете

  • Вы предпочитаете традиционный монолит

  • Вам нужен .NET, Python или другой язык для бекенда

Финальный обзор

@startuml
skinparam backgroundColor #FEFEFE

package "Полная гибридная архитектура" {

  actor "Пользователи" as users

  rectangle "Frontend (статический)" #SkyBlue {
    [JBake / GitHub Pages]
    note right: Бесплатно, глобальная CDN
  }

  rectangle "Простой Backend (Supabase)" #LightGreen {
    [Auth OAuth2]
    [CRUD APIs]
    [Storage]
    [Realtime]
    note right
Бесплатно до 50k users
Ноль конфигурации сервера
    end note
  }

  rectangle "Бизнес-бэкенд (Spring Boot)" #Coral {
    [Orchestration]
    [Jobs Planifiés]
    [Intégrations]
    [Transactions]
    note right
Активируется только
при необходимости
    end note
  }

  database "PostgreSQL\nЕдиный источник истины" as db #LightGray

  users --> [JBake / GitHub Pages]

  [JBake / GitHub Pages] --> [Auth OAuth2]
  [JBake / GitHub Pages] --> [CRUD APIs]
  [JBake / GitHub Pages] --> [Storage]
  [JBake / GitHub Pages] --> [Realtime]
  [JBake / GitHub Pages] --> [Orchestration]

  [Auth OAuth2] --> db
  [CRUD APIs] --> db
  [Orchestration] --> db
  [Jobs Planifiés] --> db
  [Intégrations] --> db
}

note bottom of db
**Одна база, два потребителя**
• Supabase для простого
• Spring Boot для сложного
• Синхронизация не требуется
end note

@enduml

Лучшее из двух миров

Эта архитектура даёт вам:

🚀 Скорость Supabase

  • Запуск в часах, а не в неделях

  • Аутентификация OAuth2 за несколько кликов

  • Автоматически сгенерированные REST API

  • Нулевая конфигурация сервера

💪 Сила Spring Boot

  • Kotlin и Coroutines для элегантного асинхронного кода

  • Оркестрация сложных бизнес-процессов

  • Надёжные запланированные задания

  • Гарантированные транзакции ACID

  • Полная экосистема Spring

💰 Прогрессивная экономика

  • 0€ для запуска и подтверждения

  • Затраты, следующие за ростом

  • Нет преждевременного переусложнения

🎯 Архитектурная гибкость

  • Постепенная миграция без рефакторинга

  • Добавление Spring Boot только при необходимости

  • Отсутствие полной привязки к поставщику

  • Эволюционная архитектура

Чтобы пойти дальше

Технические ресурсы

Документация Supabase :

Документация Spring Boot :

Дополнительные статьи :

  • Защита API с использованием JWT

  • Оптимизация производительности PostgreSQL

  • Шаблоны прогрессивной миграции

  • Управление ошибками в распределённой архитектуре

Реальные случаи использования

Эта гибридная архитектура успешно используется в:

  • SaaS B2BАутентификация Supabase, оплата Spring Boot

  • Маркетплейсы: Каталог Supabase, транзакции Spring Boot

  • Платформы контента: Статьи Supabase, аналитика Spring Boot

  • внутренние инструменты: CRUD Supabase, workflows Spring Boot

Чек‑лист запуска

Фаза 1 - Основания (Неделя 1)

  • Создать аккаунт Supabase - [ ] Настроить проект PostgreSQL - [ ] Включить аутентификацию (Google, GitHub) - [ ] Определить начальную схему - [ ] Настроить Row Level Security - [ ] Тестировать API из JBake

Phase 2 - MVP (Неделя 2-3)

  • Реализовать основные страницы - [ ] Интегрировать аутентификацию OAuth2 - [ ] Создать CRUD формы - [ ] Настроить хранилище для файлов - [ ] Развернуть на GitHub Pages - [ ] Тестировать в реальных условиях

Фаза 3 - Эволюция (Согласно потребностям)

  • Идентифицировать потребности сложной логики - [ ] Создать проект Spring Boot, если необходимо - [ ] Настроить валидацию JWT Supabase - [ ] Подключить к PostgreSQL Supabase - [ ] Мигрировать сложные функции - [ ] Внедрить запланированные задачи - [ ] Развернуть Spring Boot (Cloud Run, и т.д.)

Антипаттерны, которых следует избегать

❌ Не делать :

  • Дублировать данные между Supabase и Spring Boot

  • Создать две отдельные базы данных PostgreSQL

  • Реализовать аутентификацию самостоятельно

  • Использовать Spring Boot для простого CRUD

  • Переусложнять с самого начина

  • Игнорировать уровень безопасности строк Supabase

✅ Лучше сделать :

  • Разделять одну базу PostgreSQL

  • Пусть Supabase управляет аутентификацией

  • Использовать Spring Boot только для сложности

  • Начать просто, постепенно развиваться

  • Использовать сильные сторон каждой технологии

  • Защитить с помощью RLS на уровне базы данных

Перспективы эволюции

Добавление новых возможностей

@startuml
skinparam backgroundColor #FEFEFE

rectangle "Текущая архитектура" #SkyBlue {
  [JBake]
  [Supabase]
  [Spring Boot]
}

rectangle "Возможные изменения" #LightYellow {

  package "Производительность" {
    [Redis Cache]
    [CDN pour Assets]
    [PostgreSQL Replicas]
  }

  package "Мониторинг" {
    [Grafana]
    [Prometheus]
    [Sentry]
  }

  package "CI/CD" {
    [GitHub Actions]
    [Tests Automatisés]
    [Déploiement Continu]
  }

  package "Функциональные возможности" {
    [Search (ElasticSearch)]
    [Queue (RabbitMQ)]
    [Event Sourcing]
  }
}

[Spring Boot] .down.> [Redis Cache] : Peut ajouter
[Spring Boot] .down.> [Queue (RabbitMQ)] : Peut ajouter
[Spring Boot] .down.> [Search (ElasticSearch)] : Peut ajouter

[Supabase] .down.> [PostgreSQL Replicas] : Peut ajouter

note bottom
**Расширяемая архитектура**
Каждое дополнение независимо
Глобальный пересмотр не требуется
end note
@enduml

Горизонтальное масштабирование

Когда ваше приложение растет, гибридная архитектура естественно масштабируется :

Supabase :

  • Автоматически масштабируется до миллионов операций

  • Реплики чтения для производительности чтения

  • Восстановление по точке во времени для обеспечения безопасности

Spring Boot :

  • Множество экземпляров за балансировщиком нагрузки

  • Безсостоятельный дизайн облегчает горизонтальное масштабирование

  • Kubernetes для оркестрации при необходимости

PostgreSQL:

  • Разбиение для больших таблиц

  • Пул соединений (PgBouncer)

  • Sharding, если это действительно необходимо (редко)

Архитектурные свидетельства

Стартап SaaS (50k пользователей)

_ Мы начали с 100% Supabase. При 5 тыс. пользователей мы добавили Spring Boot только для выставления счетов Stripe и ежемесячных отчетов. Через год 80% наших операций по‑прежнему проходят через Supabase. Spring Boot управляет только критически важной частью. Такое разделение позволило нам масштабироваться без переработки. _

Платформа E-learning (10 тыс. пользователей)

</think> Аутентификация OAuth2 Supabase сэкономила нам три недели разработки. Автоматически сгенерированные API управляют всем нашим каталогом курсов. Spring Boot используется только для PDF-сертификатов и писем о прогрессе. Простая, поддерживаемая, масштабируемая архитектура. __

Маркетплейс B2B (3k пользователей)

_ Spring Boot управляет транзакциями между покупателями и продавцами (критично). Supabase управляет всем остальным: профили, обмен сообщениями в реальном времени, документы. То, что они используют одну и ту же базу PostgreSQL, избавляет нас от сложной синхронизации. Лучший архитектурный выбор, который мы сделали. _

Синтез: Современная архитектурная парадигма

Гибридная архитектура Supabase + Spring Boot представляет собой новый парадигма:архитектурная специализация.

@startuml
skinparam backgroundColor #FEFEFE

rectangle "Старая парадигма" #LightCoral {
  card "Все в Backend" {
    [Auth]
    [CRUD]
    [Logique Métier]
    [Jobs]
    [Storage]
    [Realtime]
  }
  note bottom
Максимальная сложность
с первого дня
  end note
}

rectangle "Новая парадигма" #LightGreen {
  card "Supabase\n(Удобство)" {
    [Auth]
    [CRUD Simple]
    [Storage]
    [Realtime]
  }

  card "Spring Boot\n(Дифференциация)" {
    [Logique Métier]
    [Jobs]
    [Intégrations]
  }

  note bottom
Прогрессивная сложность,
добавляемая только при необходимости
  end note
}

[Ancien Paradigme] -right-> [Nouveau Paradigme] : Évolution

@enduml

Основной принцип:Не стройте то, что уже существует в виде услуги. Сосредоточьтесь на том, что отличает ваше приложение.

Правило 80/20

В большинстве приложений:

  • 80% операцийявляются стандартным CRUD → Supabase

  • 20% операцийтребуют бизнес-логики → Spring Boot

Это естественное правило оправдывает гибридную архитектуру.

@startuml
skinparam backgroundColor #FEFEFE

package "Распределение операций" {

  rectangle "80% — Стандартные операции" #LightGreen {
    [Lecture de données]
    [Création d'entités]
    [Mise à jour simple]
    [Suppression]
    [Upload fichiers]
    [Authentification]

    note bottom: **Управляется Supabase**
  }

  rectangle "20% — Бизнес-логика" #Coral {
    [Calculs complexes]
    [Workflows multi-étapes]
    [Transactions critiques]
    [Intégrations tierces]
    [Jobs planifiés]

    note bottom: Управляется Spring Boot
  }
}

note right
**Оптимальный фокус:**
Ваше время разработки,
сосредоточенное на тех 20%, которые
выделяют ваш продукт
end note
@enduml

Финальное заключение

Гибридная архитектура не является техническим компромиссом, этостратегическое решение.

Она позволяет вам:

  • ✅ Запустить быстро с рабочим MVP

  • ✅ Подтвердите ваш рынок без больших вложений

  • ✅ Развиваться постепенно, когда сложность этого требует

  • ✅ Контролируйте свои расходы на каждом этапе

  • Использовать лучшее из каждой технологии

  • ✅ Избегать преждевременного перепроектирования

  • ✅ Сохранить гибкость на будущее

Она представляет:

  • ПрагматизмКаждая технология, в которой она преуспевает

  • 🚀Скорость: Минимальное время вывода на рынок

  • 💰ЭкономикаЗатраты, соответствующие стоимости

  • 🔮масштабируемость: Архитектура, которая растёт вместе с вами

  • 🛡️надёжность: Проверенные и надежные услуги

Ваш следующий шаг

Если эта архитектура вам близка, вот с чего начать:

  1. Создайте аккаунт Supabase(бесплатно)

  2. Определите свою минимальную схему данных

  3. Настройте аутентификацию OAuth2

  4. Создайте свою первую страницу JBake, которая использует API

  5. Разверните на GitHub Pages

Вы получите рабочий MVP занесколько дней.

Spring Boot придёт естественно, когда вам это понадобится. Не раньше.

Гибридная архитектура — это искусство строить именно то, что нужно, когда это нужно.

Hорошего развития! 🚀

Поделитесь этой статьёй, если считаете, что она может помочь другим разработчикам сделать правильные архитектурные решения.

Похожие статьи

HyperFrames-Gradle : преобразование AsciiDoc в видео MP4
31 May 2026
Аудит моего потребления LLM : SQLite, OpenCode, Ollama Cloud, и почему моя подписка Pro взрывает мировой рынок
18 May 2026
Архитектура «Независимый плагин + Корневой потребитель»: почему мои Gradle-сборки дублируются
14 May 2026
Le Knowledge Graph comme moteur de recommandation : comment j'ai tué les « articles connexes » chronologiques
12 May 2026