Django duomenų bazių maršrutizavimas: daugelio duomenų bazių konfigūracijų valdymas

Django, galingas Python žiniatinklio karkasas, suteikia lankstų mechanizmą valdyti kelias duomenų bazes viename projekte. Ši funkcija, žinoma kaip duomenų bazių maršrutizavimas, leidžia jums nukreipti skirtingas duomenų bazių operacijas (skaitymus, rašymus, migracijas) į konkrečias duomenų bazes, įgalindama sudėtingas architektūras duomenų atskyrimui, skaidymui ir skaitymo replikų įgyvendinimams. Šis išsamus vadovas gilinsis į Django duomenų bazių maršrutizavimo subtilybes, apimdamas viską nuo pagrindinės konfigūracijos iki pažangių technikų.

Kodėl naudoti daugelio duomenų bazių konfigūracijas?

Prieš gilinantis į technines detales, svarbu suprasti motyvus, kodėl naudojama daugelio duomenų bazių sąranka. Štai keli įprasti scenarijai, kur duomenų bazių maršrutizavimas yra neįkainojamas:

• Duomenų atskyrimas: Duomenų atskyrimas pagal funkcionalumą arba departamentą. Pavyzdžiui, galite saugoti vartotojų profilius vienoje duomenų bazėje, o finansines operacijas – kitoje. Tai pagerina saugumą ir supaprastina duomenų valdymą. Įsivaizduokite pasaulinę el. komercijos platformą; atskiriant klientų duomenis (vardus, adresus) nuo operacijų duomenų (užsakymų istorija, mokėjimo informacija) suteikiamas papildomas jautrios finansinės informacijos apsaugos sluoksnis.
• Skaidymas: Duomenų paskirstymas keliose duomenų bazėse siekiant pagerinti našumą ir mastelį. Pagalvokite apie socialinės žiniasklaidos platformą su milijonais vartotojų. Vartotojų duomenų skaidymas pagal geografinį regioną (pvz., Šiaurės Amerika, Europa, Azija) leidžia greičiau pasiekti duomenis ir sumažinti apkrovą atskiroms duomenų bazėms.
• Skaitymo replikos: Skaitymo operacijų perkėlimas į tik skaitymui skirtas pagrindinės duomenų bazės replikas, siekiant sumažinti pagrindinės duomenų bazės apkrovą. Tai ypač naudinga programoms, kuriose daug skaitoma. Pavyzdys galėtų būti naujienų svetainė, kuri naudoja kelias skaitymo replikas, kad apdorotų didelį srautą pranešimų apie naujienas metu, o pagrindinė duomenų bazė tvarko turinio atnaujinimus.
• Senosios sistemos integracija: Prisijungimas prie skirtingų duomenų bazių sistemų (pvz., PostgreSQL, MySQL, Oracle), kurios jau gali egzistuoti organizacijoje. Daugelis didelių korporacijų turi senas sistemas, kurios naudoja senesnes duomenų bazių technologijas. Duomenų bazių maršrutizavimas leidžia Django programoms sąveikauti su šiomis sistemomis nereikalaujant visiškos migracijos.
• A/B testavimas: A/B testų vykdymas su skirtingais duomenų rinkiniais nepaveikiant gamybos duomenų bazės. Pavyzdžiui, internetinė rinkodaros įmonė gali naudoti atskiras duomenų bazes, kad stebėtų skirtingų skelbimų kampanijų ir nukreipimo puslapių dizaino našumą.
• Mikroservisų architektūra: Mikroservisų architektūroje kiekvienas servisas dažnai turi savo dedikuotą duomenų bazę. Django duomenų bazių maršrutizavimas palengvina šių servisų integraciją.

Kelių duomenų bazių konfigūravimas Django

Pirmasis žingsnis įgyvendinant duomenų bazių maršrutizavimą yra `DATABASES` nustatymo konfigūravimas jūsų `settings.py` faile. Šis žodynas apibrėžia kiekvienos duomenų bazės ryšio parametrus.

```python DATABASES = { 'default': { 'ENGINE': 'django.db.backends.postgresql', 'NAME': 'mydatabase', 'USER': 'mydatabaseuser', 'PASSWORD': 'mypassword', 'HOST': '127.0.0.1', 'PORT': '5432', }, 'users': { 'ENGINE': 'django.db.backends.mysql', 'NAME': 'user_database', 'USER': 'user_db_user', 'PASSWORD': 'user_db_password', 'HOST': 'db.example.com', 'PORT': '3306', }, 'analytics': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': 'analytics.db', }, } ```

Šiame pavyzdyje mes apibrėžėme tris duomenų bazes: `default` (PostgreSQL duomenų bazė), `users` (MySQL duomenų bazė) ir `analytics` (SQLite duomenų bazė). `ENGINE` nustatymas nurodo, kurią duomenų bazės posistemę naudoti, o kiti nustatymai pateikia reikiamą ryšio informaciją. Nepamirškite įdiegti atitinkamų duomenų bazės tvarkyklių (pvz., `psycopg2` PostgreSQL, `mysqlclient` MySQL) prieš konfigūruodami šiuos nustatymus.

Duomenų bazės maršrutizatoriaus kūrimas

Django duomenų bazių maršrutizavimo esmė yra duomenų bazės maršrutizatoriaus klasių kūrimas. Šios klasės apibrėžia taisykles, pagal kurias nustatoma, kuri duomenų bazė turėtų būti naudojama konkrečioms modelio operacijoms. Maršrutizatoriaus klasė turi įgyvendinti bent vieną iš šių metodų:

• `db_for_read(model, **hints)`: Grąžina duomenų bazės slapyvardį, kuris bus naudojamas skaitymo operacijoms su nurodytu modeliu.
• `db_for_write(model, **hints)`: Grąžina duomenų bazės slapyvardį, kuris bus naudojamas rašymo operacijoms (kurti, atnaujinti, ištrinti) su nurodytu modeliu.
• `allow_relation(obj1, obj2, **hints)`: Grąžina `True`, jei ryšys tarp `obj1` ir `obj2` yra leidžiamas, `False`, jei jis neleidžiamas, arba `None`, jei neturi nuomonės.
• `allow_migrate(db, app_label, model_name=None, **hints)`: Grąžina `True`, jei migracijos turėtų būti taikomos nurodytai duomenų bazei, `False`, jei jos turėtų būti praleistos, arba `None`, jei neturi nuomonės.

Sukurkime paprastą maršrutizatorių, kuris nukreipia visas operacijas su modeliais `users` programoje į `users` duomenų bazę:

```python # routers.py class UserRouter: """ A router to control all database operations on models in the users application. """ route_app_labels = {'users'} def db_for_read(self, model, **hints): """ Attempts to read users models go to users_db. """ if model._meta.app_label in self.route_app_labels: return 'users' return None def db_for_write(self, model, **hints): """ Attempts to write users models go to users_db. """ if model._meta.app_label in self.route_app_labels: return 'users' return 'default' def allow_relation(self, obj1, obj2, **hints): """ Allow relations if a model in the users app is involved. """ if ( obj1._meta.app_label in self.route_app_labels or obj2._meta.app_label in self.route_app_labels ): return True return None def allow_migrate(self, db, app_label, model_name=None, **hints): """ Make sure the users app only appears in the 'users' database. """ if app_label in self.route_app_labels: return db == 'users' return True ```

Šis maršrutizatorius tikrina, ar modelio programos etiketė yra `route_app_labels`. Jei taip, jis grąžina `users` duomenų bazės slapyvardį skaitymo ir rašymo operacijoms. `allow_relation` metodas leidžia ryšius, jei įtrauktas modelis iš `users` programos. `allow_migrate` metodas užtikrina, kad `users` programos migracijos būtų taikomos tik `users` duomenų bazei. Labai svarbu teisingai įgyvendinti `allow_migrate`, kad būtų išvengta duomenų bazės nenuoseklumų.

Maršrutizatoriaus aktyvavimas

Norėdami suaktyvinti maršrutizatorių, turite jį pridėti prie `DATABASE_ROUTERS` nustatymo savo `settings.py` faile:

```python DATABASE_ROUTERS = ['your_project.routers.UserRouter'] ```

Pakeiskite `your_project.routers.UserRouter` faktiniu keliu į savo maršrutizatoriaus klasę. Maršrutizatorių tvarka šiame sąraše yra svarbi, nes Django kartos per juos tol, kol vienas grąžins ne `None` reikšmę. Jei nė vienas maršrutizatorius negrąžina duomenų bazės slapyvardžio, Django naudos `default` duomenų bazę.

Pažangios maršrutizavimo technikos

Ankstesnis pavyzdys parodo paprastą maršrutizatorių, kuris maršrutizuoja pagal programos etiketę. Tačiau galite sukurti sudėtingesnius maršrutizatorius pagal įvairius kriterijus.

Maršrutizavimas pagal modelio klasę

Galite maršrutizuoti pagal pačią modelio klasę. Pavyzdžiui, galite norėti nukreipti visas konkretaus modelio skaitymo operacijas į skaitymo repliką:

```python class ReadReplicaRouter: """ Routes read operations for specific models to a read replica. """ read_replica_models = ['myapp.MyModel', 'anotherapp.AnotherModel'] def db_for_read(self, model, **hints): if f'{model._meta.app_label}.{model._meta.model_name.capitalize()}' in self.read_replica_models: return 'read_replica' return None def db_for_write(self, model, **hints): return 'default' def allow_relation(self, obj1, obj2, **hints): return True def allow_migrate(self, db, app_label, model_name=None, **hints): return True ```

Šis maršrutizatorius tikrina, ar modelio pilnas pavadinimas yra `read_replica_models`. Jei taip, jis grąžina `read_replica` duomenų bazės slapyvardį skaitymo operacijoms. Visos rašymo operacijos nukreipiamos į `default` duomenų bazę.

Patarimų naudojimas

Django pateikia `hints` žodyną, kurį galima naudoti papildomai informacijai perduoti maršrutizatoriui. Galite naudoti patarimus, kad dinamiškai nustatytumėte, kurią duomenų bazę naudoti, atsižvelgiant į vykdymo sąlygas.

```python # views.py from django.db import connections from myapp.models import MyModel def my_view(request): # Force reads from the 'users' database instance = MyModel.objects.using('users').get(pk=1) # Create a new object using 'analytics' database new_instance = MyModel(name='New Object') new_instance.save(using='analytics') return HttpResponse("Success!") ```

`using()` metodas leidžia nurodyti, kurią duomenų bazę naudoti konkrečiai užklausai ar operacijai. Tada maršrutizatorius gali pasiekti šią informaciją per `hints` žodyną.

Maršrutizavimas pagal vartotojo tipą

Įsivaizduokite scenarijų, kai norite saugoti skirtingų vartotojų tipų (pvz., administratoriai, paprasti vartotojai) duomenis atskirose duomenų bazėse. Galite sukurti maršrutizatorių, kuris tikrina vartotojo tipą ir atitinkamai maršrutizuoja.

```python # routers.py from django.contrib.auth import get_user_model class UserTypeRouter: """ Routes database operations based on user type. """ def db_for_read(self, model, **hints): user = hints.get('instance') # Attempt to extract user instance if user and user.is_superuser: return 'admin_db' return 'default' def db_for_write(self, model, **hints): user = hints.get('instance') # Attempt to extract user instance if user and user.is_superuser: return 'admin_db' return 'default' def allow_relation(self, obj1, obj2, **hints): return True def allow_migrate(self, db, app_label, model_name=None, **hints): return True ```

Norėdami naudoti šį maršrutizatorių, turite perduoti vartotojo egzempliorių kaip patarimą atliekant duomenų bazės operacijas:

```python # views.py from myapp.models import MyModel def my_view(request): user = request.user instance = MyModel.objects.using('default').get(pk=1) # Pass the user instance as a hint during save new_instance = MyModel(name='New Object') new_instance.save(using='default', update_fields=['name'], instance=user) # Pass user as instance return HttpResponse("Success!") ```

Tai užtikrins, kad operacijos, susijusios su administratoriaus vartotojais, būtų maršrutizuojamos į `admin_db` duomenų bazę, o operacijos, susijusios su paprastais vartotojais, būtų maršrutizuojamos į `default` duomenų bazę.

Atsižvelgiant į migracijas

Migracijų valdymas kelių duomenų bazių aplinkoje reikalauja kruopštaus dėmesio. `allow_migrate` metodas jūsų maršrutizatoriuje atlieka svarbų vaidmenį nustatant, kurios migracijos taikomos kiekvienai duomenų bazei. Būtina įsitikinti, kad suprantate ir tinkamai naudojate šį metodą.

Vykdydami migracijas galite nurodyti duomenų bazę, kurią norite migruoti, naudodami parinktį `--database`:

```bash python manage.py migrate --database=users ```

Tai taikys migracijas tik `users` duomenų bazei. Būtinai vykdykite migracijas kiekvienai duomenų bazei atskirai, kad užtikrintumėte, jog jūsų schema yra nuosekli visose duomenų bazėse.

Kelių duomenų bazių konfigūracijų testavimas

Testuoti savo duomenų bazių maršrutizavimo konfigūraciją būtina norint užtikrinti, kad ji veikia taip, kaip tikėtasi. Galite naudoti Django testavimo karkasą, kad parašytumėte vienetinius testus, patvirtinančius, kad duomenys rašomi į teisingas duomenų bazes.

```python # tests.py from django.test import TestCase from myapp.models import MyModel from django.db import connections class DatabaseRoutingTest(TestCase): def test_data_is_written_to_correct_database(self): # Create an object instance = MyModel.objects.create(name='Test Object') # Check which database the object was saved to db = connections[instance._state.db] self.assertEqual(instance._state.db, 'default') # Replace 'default' with expected database # Retrieve object from specific database instance_from_other_db = MyModel.objects.using('users').get(pk=instance.pk) # Make sure there are no errors, and that everything is working as expected self.assertEqual(instance_from_other_db.name, "Test Object") ```

Šis testavimo atvejis sukuria objektą ir patikrina, ar jis buvo išsaugotas numatytoje duomenų bazėje. Galite parašyti panašius testus, kad patikrintumėte skaitymo operacijas ir kitus savo duomenų bazių maršrutizavimo konfigūracijos aspektus.

Našumo optimizavimas

Nors duomenų bazių maršrutizavimas suteikia lankstumo, svarbu atsižvelgti į galimą jo poveikį našumui. Štai keletas patarimų, kaip optimizuoti našumą kelių duomenų bazių aplinkoje:

• Sumažinkite kryžminių duomenų bazių sujungimus: Kryžminiai duomenų bazių sujungimai gali būti brangūs, nes jiems reikia perkelti duomenis tarp duomenų bazių. Stenkitės jų vengti, kai tik įmanoma.
• Naudokite talpyklą: Talpykla gali padėti sumažinti duomenų bazių apkrovą saugant dažnai pasiekiamus duomenis atmintyje.
• Optimizuokite užklausas: Užtikrinkite, kad jūsų užklausos būtų gerai optimizuotos, kad sumažintumėte duomenų kiekį, kurį reikia nuskaityti iš duomenų bazių.
• Stebėkite duomenų bazės našumą: Reguliariai stebėkite savo duomenų bazių našumą, kad nustatytumėte kliūtis ir tobulinimo sritis. Tokios priemonės kaip Prometheus ir Grafana gali suteikti vertingų įžvalgų apie duomenų bazės našumo metrikas.
• Ryšio telkinys: Naudokite ryšio telkinį, kad sumažintumėte naujų duomenų bazės ryšių užmezgimo išlaidas. Django automatiškai naudoja ryšio telkinį.

Geriausia duomenų bazių maršrutizavimo praktika

Štai keletas geriausių praktikų, kurių reikia laikytis įgyvendinant duomenų bazių maršrutizavimą Django:

• Laikykite maršrutizatorius paprastus: Venkite sudėtingos logikos savo maršrutizatoriuose, nes tai gali apsunkinti jų priežiūrą ir derinimą. Paprastos, aiškiai apibrėžtos maršrutizavimo taisyklės yra lengviau suprantamos ir pašalinamos triktys.
• Dokumentuokite savo konfigūraciją: Aiškiai dokumentuokite savo duomenų bazių maršrutizavimo konfigūraciją, įskaitant kiekvienos duomenų bazės paskirtį ir galiojančias maršrutizavimo taisykles.
• Kruopščiai testuokite: Parašykite išsamius testus, kad patikrintumėte, ar jūsų duomenų bazių maršrutizavimo konfigūracija veikia teisingai.
• Apsvarstykite duomenų bazės nuoseklumą: Atminkite duomenų bazės nuoseklumą, ypač kai dirbate su keliomis rašymo duomenų bazėmis. Duomenų vientisumui palaikyti gali prireikti tokių technikų kaip paskirstytosios operacijos arba galutinis nuoseklumas.
• Planuokite mastelį: Projektuokite savo duomenų bazių maršrutizavimo konfigūraciją galvodami apie mastelį. Apsvarstykite, kaip reikės keisti jūsų konfigūraciją, kai jūsų programa augs.

Alternatyvos Django duomenų bazių maršrutizavimui

Nors Django įmontuotas duomenų bazių maršrutizavimas yra galingas, yra situacijų, kai tinkamesni gali būti alternatyvūs metodai. Štai keletas alternatyvų, kurias reikia apsvarstyti:

• Duomenų bazės rodiniai: Tik skaitymui skirtiems scenarijams duomenų bazės rodiniai gali suteikti būdą pasiekti duomenis iš kelių duomenų bazių nereikalaujant programos lygmens maršrutizavimo.
• Duomenų saugykla: Jei jums reikia sujungti duomenis iš kelių duomenų bazių ataskaitų teikimui ir analizei, duomenų saugyklos sprendimas gali būti tinkamesnis.
• Duomenų bazė kaip paslauga (DBaaS): Debesų pagrindu veikiantys DBaaS teikėjai dažnai siūlo tokias funkcijas kaip automatinis skaidymas ir skaitymo replikų valdymas, o tai gali supaprastinti kelių duomenų bazių dislokavimą.

Išvada

Django duomenų bazių maršrutizavimas yra galinga funkcija, leidžianti valdyti kelias duomenų bazes viename projekte. Suprasdami šiame vadove pateiktas koncepcijas ir technikas, galite efektyviai įgyvendinti kelių duomenų bazių konfigūracijas duomenų atskyrimui, skaidymui, skaitymo replikoms ir kitiems pažangiems scenarijams. Nepamirškite kruopščiai suplanuoti savo konfigūraciją, parašyti išsamius testus ir stebėti našumą, kad užtikrintumėte, jog jūsų kelių duomenų bazių sąranka veikia optimaliai. Šis pajėgumas suteikia kūrėjams įrankius kurti mastelio keičiamas ir patikimas programas, kurios gali tvarkyti sudėtingus duomenų reikalavimus ir prisitaikyti prie besikeičiančių verslo poreikių visame pasaulyje. Įvaldyti šią techniką yra vertingas turtas bet kuriam Django kūrėjui, dirbančiam su dideliais, sudėtingais projektais.