Django模型跨多个项目/微服务。 如何？

Question

I'm wondering how to solve sharing of the model structure between multiple (separated) django projects/microservices. Eg:

1. Project: API
2. Project: Users dashboard
3. Project: Admin dashboard
4. Project: Statistics

Each of that projects uses the same django models. Is there a one, proper way to solve that?

Answer 1

Django basic idea is to couple the entire app functionality together, but this does not hold in your case. It's a style and opinion question, here is what I did in a similar situation.

Split the app functionality into two project lairs:

mysite
   |
   | - db_access
   |         | --- app1
   |                 | ---- models.py
   |                 | ---- db_api.py
   |         | --- app2
   |                 | ---- models.py
   |                 | ---- db_api.py
   | - service
   |         | --- app1
   |                 | ---- urls.py
   |                 | ---- views.py
   |         | --- app2
   |                 | ---- urls.py
   |                 | ---- views.py

The db_access part has the models, and db_api.py has the queries, get objects etc, so you don't query the models, but the db_api.

Instead of

item = app1.models.Items.objects.get(user=request.user)

Use

item = app1.db_api.get_first_item(user=request.user)

This style lets you share the db & models access together, while each service consumes what it needs, and then use it for API, website etc. If a service consumes some data in a way that other services don't (and will not) use, then put this query in the service code, otherwise in the db_api.py.

This is more like a traditional laired application, but it works.

Another thing, the same project can use two git repositories, one for the db_access (which all services pull), and one for the specific service. So each django project is actually the db_access repo, and the service repo - wsgi doesn't care, of course, if the project code comes from two repositories.

Answer 2

Two potential options:

Option 1 - Use a common codebase and deploy multiple instances of it (one for each microservice). You could follow 12factor Apps Methodology and just load a different set of environment variables for each deployed instance. http://12factor.net/

Option 2 - Split your django code up into self contained applications then have a project for each microservice that just includes these projects and a url config.

I can expand further if this is helpful?

Answer 3

If you want to use same models in different python apps (not modules, but apps, with different uwsgi-instances etc.), then I think that the much common and handy solution - provide interface for these models through some API:

1. You can build REST interface in each of your projects, and then call appropriate API methods to get result.
2. You can use Celery package to build internal API based on the AMQP transport. Then you need to configure your apps to listen some RabbitMQ queue which will be used as message storage for your projects communnication.

Answer 4

Django models is just a Python module, of course Django does a lot of 'magic' in other modules (ie forms, admin) using introspection, but the models itself could be used separately if desired.

So there's no problem... If you use different "Django projects" for each project you named (on same machine or different), then just make your models as separate "Django app" and set each project to use it. If each project named by you is "Django app" (in this case on same machine obviously) then just import your models module in each "project" and use it. Even if you don't use Django, say your "API project" is based on Flask, you can still import Django models in Flask modules.

Behind the scene of Django models there's the database, which doesn't care from where it is queried, and Django just provides a convenient way to use the DB via Python classes. So if the models from different apps or projects are set to use the same DB, then they will be 'shared'.