Het opzetten van een multi-tenancy systeem in een Flask-applicatie met SQLAlchemy vereist een doordacht ontwerp om gegevensisolatie, schaalbaarheid en beveiliging te waarborgen. Hier volgen de belangrijkste aanpak en best practices: 1. Multi-tenancy Architectuurmodellen - Scheiding per database (Database-per-Tenant): Elke tenant krijgt een eigen database. Voordeel: maximale isolatie, nadeel: complexiteit bij beheer. - Scheiding per schema (Schema-per-Tenant): Eén database met gescheiden schemas voor elke tenant. Goede isolatie, minder beheer dan database-per. - Shared schema (Shared Table): Alle tenants gebruiken dezelfde tabellen, met een tenant_id kolom voor isolatie. Meest eenvoudig, maar vereist strikte queryfilters. 2. Aanbevolen aanpak: Shared schema met tenant_id Omdat je huidige structuur gebaseerd is op één Flask app en SQLAlchemy, is een shared schema met tenant_id meestal de meest praktische oplossing. 3. Database Schema Ontwerp - Voeg een kolom tenant_id toe aan alle relevante tabellen: ```python class Gebruiker(db.Model): id = db.Column(db.Integer, primary_key=True) naam = db.Column(db.String(50)) tenant_id = db.Column(db.String(36), nullable=False) ``` - Zorg dat elke query automatisch filtert op tenant_id. 4. Tenant-specifieke Instellingen - Maak een tabel voor tenantconfiguraties: ```python class TenantInstelling(db.Model): id = db.Column(db.Integer, primary_key=True) tenant_id = db.Column(db.String(36), nullable=False, unique=True) naam = db.Column(db.String(100)) instellingen = db.Column(db.JSON) ``` - Laad deze instellingen bij authenticatie of per request. 5. Beveiliging en Gegevensisolatie - Implementeer middleware of een decorator die het tenant_id valideert en automatisch toevoegt aan queries. - Gebruik SQLAlchemy’s query context of een custom query class om tenant filters te forceren. - Voorkom SQL-injecties door parameterized queries. - Zorg dat authenticatie en autorisatie strikt per tenant plaatsvinden. 6. Best Practices - Centraliseer tenantbeheer: houd een overzicht van alle tenants en hun configuraties. - Gebruik een contextmanagement systeem (bijvoorbeeld Flask’s `g` object) om tenant-specifieke gegevens op te slaan tijdens een request. - Maak gebruik van Flask’s `before_request` hook om tenant-identificatie (bijvoorbeeld via subdomein of header) te doen. - Implementeer logging en monitoring per tenant. - Test uitgebreid met meerdere tenants en verschillende configuraties. 7. Overwegingen - Back-ups en herstel: plan voor tenant-specifieke back-ups. - Schaalbaarheid: kies het juiste multi-tenancy model afhankelijk van verwachte groei. - Beveiliging: zorg dat API endpoints en database toegang strikt gescheiden zijn. Door deze aanpak te volgen, creëer je een schaalbare, veilige en goed beheersbare multi-tenancy architectuur voor je Flask applicatie met SQLAlchemy.

Hier is een uitgebreide uitleg over multi-tenancy implementatie in Flask: ## Database Schema Ontwerp ### 1. Tenant Isolatie Strategieën **Optie A: Shared Schema met tenant_id** ```python from flask_sqlalchemy import SQLAlchemy from sqlalchemy import Column, Integer, String, ForeignKey db = SQLAlchemy() class Tenant(db.Model): __tablename__ = 'tenants' id = Column(Integer, primary_key=True) name = Column(String(100), unique=True, nullable=False) subdomain = Column(String(50), unique=True, nullable=False) is_active = Column(Boolean, default=True) class User(db.Model): __tablename__ = 'users' id = Column(Integer, primary_key=True) tenant_id = Column(Integer, ForeignKey('tenants.id'), nullable=False) email = Column(String(120), nullable=False) tenant = db.relationship('Tenant', backref='users') ``` **Optie B: Schema per Tenant** (Sterkere isolatie) ```python from sqlalchemy import event from sqlalchemy.orm import sessionmaker def set_tenant_schema(tenant_schema): # Dynamisch schema wisselen per tenant pass ``` ## Tenant Management Systeem ### 2. Tenant Configuratie en Instellingen ```python class TenantConfig(db.Model): __tablename__ = 'tenant_configs' id = Column(Integer, primary_key=True) tenant_id = Column(Integer, ForeignKey('tenants.id'), nullable=False) setting_key = Column(String(100), nullable=False) setting_value = Column(Text) tenant = db.relationship('Tenant', backref='configs') class TenantManager: def __init__(self): self.current_tenant = None def set_current_tenant(self, tenant_id): self.current_tenant = tenant_id def get_tenant_config(self, key, default=None): config = TenantConfig.query.filter_by( tenant_id=self.current_tenant, setting_key=key ).first() return config.setting_value if config else default ``` ## Data Beveiliging en Isolatie ### 3. Request-scoped Tenant Filtering ```python from flask import g, request from sqlalchemy import orm class TenantAwareQuery(orm.Query): def get(self, ident): # Voeg tenant filter toe aan alle queries if hasattr(g, 'tenant_id'): return super().filter_by(tenant_id=g.tenant_id).get(ident) return super().get(ident) def first(self): if hasattr(g, 'tenant_id'): return super().filter_by(tenant_id=g.tenant_id).first() return super().first() # Configureer SQLAlchemy session db.session = orm.scoped_session( orm.sessionmaker(query_cls=TenantAwareQuery) ) ``` ### 4. Middleware voor Tenant Detectie ```python @app.before_request def identify_tenant(): # Detecteer tenant via subdomain subdomain = request.host.split('.')[0] tenant = Tenant.query.filter_by( subdomain=subdomain, is_active=True ).first() if tenant: g.tenant_id = tenant.id g.tenant = tenant else: return "Tenant niet gevonden", 404 ``` ## Beste Praktijken ### 5. Security Maatregelen **Row Level Security:** ```python def tenant_required(f): @wraps(f) def decorated_function(*args, **kwargs): if not hasattr(g, 'tenant_id'): return "Geen tenant geselecteerd", 403 return f(*args, **kwargs) return decorated_function @app.route('/api/data') @tenant_required def get_tenant_data(): # Alleen data van huidige tenant data = User.query.filter_by(tenant_id=g.tenant_id).all() return jsonify([user.serialize() for user in data]) ``` **Query Interceptie:** ```python @event.listens_for(db.session, 'do_orm_execute') def add_tenant_filter(execute_state): if (hasattr(g, 'tenant_id') and execute_state.is_select and not execute_state.is_column_load): # Voeg tenant filter toe aan alle queries for entity in execute_state.statement.froms: if hasattr(entity, 'c') and 'tenant_id' in entity.c: execute_state.statement = execute_state.statement.where( entity.c.tenant_id == g.tenant_id ) ``` ### 6. Database Migratie Strategie ```python from flask_migrate import Migrate def upgrade_tenant_schema(tenant_id): # Schema migraties per tenant with db.engine.connect() as conn: conn.execute(f"SET search_path TO tenant_{tenant_id}") # Voer tenant-specifieke migraties uit ``` ### 7. Performance Optimalisatie ```sql -- Database indexes voor multi-tenancy CREATE INDEX idx_users_tenant_id ON users(tenant_id); CREATE INDEX idx_orders_tenant_id ON orders(tenant_id); -- Partitie overwegingen voor grote datasets CREATE TABLE orders ( id SERIAL, tenant_id INTEGER, created_at TIMESTAMP ) PARTITION BY HASH (tenant_id); ``` ## Aanbevolen Implementatie Stappen 1. **Start met Shared Schema + tenant_id** voor eenvoud 2. **Implementeer strikte query filtering** in alle data-access lagen 3. **Voeg auditing toe** voor tenant-activiteiten 4. **Test isolatie grondig** met cross-tenant data toegang tests 5. **Overweeg schema-per-tenant** bij strikte compliance eisen Deze aanpak biedt een goede balans tussen ontwikkelgemak, performance en data-isolatie voor de meeste Flask multi-tenancy use cases.