Python/Django support for distributed multi-tenant databases like Postgres+Citus
MIT License
Python/Django support for distributed multi-tenant databases like Postgres+Citus
Enables easy scale-out by adding the tenant context to your queries, enabling the database (e.g. Citus) to efficiently route queries to the right database node.
There are architecures for building multi-tenant databases viz. Create one database per tenant, Create one schema per tenant and Have all tenants share the same table(s). This library is based on the 3rd design i.e Have all tenants share the same table(s), it assumes that all the tenant relates models/tables have a tenant_id column for representing a tenant.
The following link talks more about the trade-offs on when and how to choose the right architecture for your multi-tenant database:
https://www.citusdata.com/blog/2016/10/03/designing-your-saas-database-for-high-scalability/
The following blogpost is a good starting point to start to use django-multitenant https://www.citusdata.com/blog/2023/05/09/evolving-django-multitenant-to-build-scalable-saas-apps-on-postgres-and-citus/
Other useful links on multi-tenancy:
pip install --no-cache-dir django_multitenant
Python | Django | Citus |
---|---|---|
3.8 3.9 3.10 3.11 | 4.2 | 11 12 |
3.8 3.9 3.10 3.11 | 4.1 | 11 12 |
3.8 3.9 3.10 3.11 | 4.0 | 10 11 12 |
3.7 | 3.2 | 10 11 12 |
In order to use this library you can either use Mixins or have your models inherit from our custom model class.
In whichever files you want to use the library import it:
from django_multitenant.fields import *
from django_multitenant.models import *
All models should inherit the TenantModel class.
Ex: class Product(TenantModel):
Define a static variable named tenant_id and specify the tenant column using this variable.You can define tenant_id in three ways. Any of them is acceptable
Warning Using tenant_id field directly in the class is not suggested since it may cause collision if class has a field named with 'tenant'
All foreign keys to TenantModel subclasses should use TenantForeignKey in place of models.ForeignKey
A sample model implementing the above 2 steps:
class Store(TenantModel):
name = models.CharField(max_length=50)
address = models.CharField(max_length=255)
email = models.CharField(max_length=50)
class TenantMeta:
tenant_field_name = "id"
class Product(TenantModel):
store = models.ForeignKey(Store)
name = models.CharField(max_length=255)
description = models.TextField()
class Meta:
unique_together = ["id", "store"]
class TenantMeta:
tenant_field_name = "store_id"
class Purchase(TenantModel):
store = models.ForeignKey(Store)
product_purchased = TenantForeignKey(Product)
class TenantMeta:
tenant_field_name = "store_id"
from django_multitenant.mixins import *
TenantModelMixin
and the django models.Model
or your customer Model classEx: class Product(TenantModelMixin, models.Model):
Ex: tenant_id='store_id'
Ex:
class Meta:
unique_together = ["id", "store"]
class ProductManager(TenantManagerMixin, models.Manager):
pass
class Product(TenantModelMixin, models.Model):
store = models.ForeignKey(Store)
tenant_id='store_id'
name = models.CharField(max_length=255)
description = models.TextField()
objects = ProductManager()
class Meta:
unique_together = ["id", "store"]
class PurchaseManager(TenantManagerMixin, models.Manager):
pass
class Purchase(TenantModelMixin, models.Model):
store = models.ForeignKey(Store)
tenant_id='store_id'
product_purchased = TenantForeignKey(Product)
objects = PurchaseManager()
django_multitenant.backends.postgresql
. 'default': {
'ENGINE': 'django_multitenant.backends.postgresql',
......
......
......
}
Write authentication logic using a middleware which also sets/unsets a tenant for each session/request. This way developers need not worry about setting a tenant on a per view basis. Just set it while authentication and the library would ensure the rest (adding tenant_id filters to the queries). A sample implementation of the above is as follows:
from django_multitenant.utils import set_current_tenant
class MultitenantMiddleware:
def __init__(self, get_response):
self.get_response = get_response
def __call__(self, request):
if request.user and not request.user.is_anonymous:
set_current_tenant(request.user.employee.company)
return self.get_response(request)
In your settings, you will need to update the MIDDLEWARE
setting to include the one you created.
MIDDLEWARE = [
# ...
# existing items
# ...
'appname.middleware.MultitenantMiddleware'
]
Set the tenant using set_current_tenant(t) api in all the views which you want to be scoped based on tenant. This would scope all the django API calls automatically(without specifying explicit filters) to a single tenant. If the current_tenant is not set, then the default/native API without tenant scoping is used.
def application_function:
# current_tenant can be stored as a SESSION variable when a user logs in.
# This should be done by the app
t = current_tenant
#set the tenant
set_current_tenant(t);
#Django ORM API calls;
#Command 1;
#Command 2;
#Command 3;
#Command 4;
#Command 5;
s=Store.objects.all()[0]
set_current_tenant(s)
#All the below API calls would add suitable tenant filters.
#Simple get_queryset()
Product.objects.get_queryset()
#Simple join
Purchase.objects.filter(id=1).filter(store__name='The Awesome Store').filter(product__description='All products are awesome')
#Update
Purchase.objects.filter(id=1).update(id=1)
#Save
p=Product(8,1,'Awesome Shoe','These shoes are awesome')
p.save()
#Simple aggregates
Product.objects.count()
Product.objects.filter(store__name='The Awesome Store').count()
#Subqueries
Product.objects.filter(name='Awesome Shoe');
Purchase.objects.filter(product__in=p);
This library uses similar logic of setting/getting tenant object as in django-simple-multitenant. We thank the authors for their efforts.
Copyright (C) 2023, Citus Data Licensed under the MIT license, see LICENSE file for details.