Kreiranje Django modela: Vodič

Hark Labs2022-03-08 · 11 min read

Django je poznati web okvir za brzi razvoj sigurnih web stranica i web aplikacija koje se lako održavaju. Izgrađen pomoću Python, Django pojednostavljuje web razvoj, omogućujući više vremena i fokusa na pisanje aplikacija bez ponovnog izmišljanja kotača svaki put. Django je besplatan projekt otvorenog koda s robusnom službenom dokumentacijom, izvrsnom podrškom zajednice i mnoštvom besplatne i plaćene podrške.

U ovom vodiču, uronit ćemo u stvaranje Django modela. U Djangu, a model je ključni izvor informacija o vašim podacima. Modeli opisuju polja i ponašanje podataka koji se pohranjuju. Django koristi model za generiranje tablica baze podataka pomoću ORM-a (Object Relational Mapping), koji se također nazivaju modeli.

Preduvjeti

Radimo na operacijskom sustavu baziranom na Unixu, po mogućnosti na Ubuntu 20.04 cloud poslužitelju kao sustavu na kojem smo testirali. Ako želite postaviti Django u sličnom okruženju, pogledajte naš vodič, „Kako instalirati Django i postaviti razvojno okruženje na Ubuntu 20.04.”

Korak 1. Python razvojno okruženje

Django je izgrađen na Pythonu. Dakle, trebamo robusno Python razvojno okruženje sa svim potrebnim alatima za rad s Python aplikacijama. O tome smo već raspravljali u namjenskom vodiču. Ovdje ćemo imati kratku demonstraciju.

Prvo pokrenite terminal i pokrenite sljedeće naredbe:

$ sudo apt update && sudo apt upgrade -y
$ sudo apt install python3 python-is-python3

1 2	$ sudo apt update && sudo apt upgrade -y $ sudo apt install python3 python-is-python3

Zatim instalirajte pip – upravitelj Python paketa:

$ sudo apt install python3-pip

1	$ sudo apt install python3-pip

Zatim instalirajte neke dodatne razvojne pakete:

$ sudo apt install build-essential libssl-dev libffi-dev python3-dev

1	$ sudo apt install build-essential libssl-dev libffi-dev python3-dev

Za uspostavljanje virtualnog okruženja također nam je potreban Pythonov venv modul:

$ sudo apt install python3-venv

1	$ sudo apt install python3-venv

Korak 2. Instalacija MySQL poslužitelja

MySQL je popularan sustav za upravljanje relacijskim bazama podataka. Otvorenog je koda, stabilan i bogat značajkama. Koristit ćemo MySQL kao poslužitelj baze podataka za našu Django aplikaciju. Instalirajte MySQL pomoću APT-a:

$ sudo apt install mysql-server

1	$ sudo apt install mysql-server

Zatim provjerite instalaciju:

$ systemctl status mysql

1	$ systemctl status mysql

To je samo osnovna konfiguracija MySQL-a sa zadanim opcijama. Pogledajte detaljniji vodič o instalaciji i konfiguraciji MySQL-a.

Korak 3. Postavljanje Django aplikacije

Sada smo spremni za stvaranje naše Django aplikacije. Ako ste zainteresirani za daljnju detaljnu demonstraciju Djanga, pogledajte naš vodič, „Instalacija Django web okvira na Ubuntu 20.04.”

Zatim stvorite namjenski direktorij za aplikaciju. Naziv direktorija trebao bi odražavati naziv projekta:

$ mkdir -pv <project_dir>

1	$ mkdir -pv <project_dir>

Unutar direktorija projekta stvorite Python virtualno okruženje pomoću venv modula:

$ python3 -m venv <virtual_env_name>

1	$ python3 -m venv <virtual_env_name>

Aktivirajte virtualno okruženje:

$ . sample_app_env/bin/activate

1	$ . sample_app_env/bin/activate

Instalirajte Django pomoću pip:

$ pip install django

1	$ pip install django

Zatim stvorite novi Django projekt pomoću django-admin naredbe:

$ django-admin startproject sample_app

1	$ django-admin startproject sample_app

Korak 4. Konfiguriranje Django aplikacije

Django aplikacija sadrži sve zadane konfiguracije. Za naš cilj moramo napraviti neke prilagodbe.

Započnite uređivanjem konfiguracijske datoteke settings.py:

$ nano sample_app/sample_app/sample_app/settings.py

1	$ nano sample_app/sample_app/sample_app/settings.py

Zatim promijenite vremensku zonu:

$ TIME_ZONE = '<time_zone>'

1	$ TIME_ZONE = '<time_zone>'

Dodajte strojeve kojima je dopušten pristup poslužitelju Django aplikacije:

$ ALLOWED_HOSTS = ['<allowed_host_ip_or_domain_name >']

1	$ ALLOWED_HOSTS = ['<allowed_host_ip_or_domain_name >']

Nakon toga primijenite promjene:

$ python manage.py migrate

1	$ python manage.py migrate

Na kraju, stvorite superkorisnika za našu Django web aplikaciju:

$ python manage.py createsuperuser

1	$ python manage.py createsuperuser

Korak 5. Povezivanje Django aplikacije s MySQL-om

Za povezivanje s MySQL-om, potrebna nam je dodatna Python biblioteka konektora koja je kompatibilna s Djangom. Koristit ćemo mysqlclient.

Prvo provjerite imamo li instalirane potrebne pakete:

$ sudo apt install python3-dev libmysqlclient-dev default-libmysqlclient-dev

1	$ sudo apt install python3-dev libmysqlclient-dev default-libmysqlclient-dev

Zatim instalirajte mysqlclient:

$ pip install mysqlclient

1	$ pip install mysqlclient

Stvaranje namjenske baze podataka

Za našu aplikaciju moramo stvoriti namjensku bazu podataka i korisnika baze podataka. Pokrenite MySQL ljusku kao root:

$ sudo mysql -u root

1	$ sudo mysql -u root

Stvorite namjensku bazu podataka za našu Django aplikaciju:

$ CREATE DATABASE <dedicated_database>;

1	$ CREATE DATABASE <dedicated_database>;

Zatim stvorite namjenskog korisnika baze podataka za Django aplikaciju:

$ CREATE USER '<username>'@'%' IDENTIFIED WITH mysql_native_password BY '<user_password>';

1	$ CREATE USER '<username>'@'%' IDENTIFIED WITH mysql_native_password BY '<user_password>';

Na kraju, dodijelite namjenskom korisniku sve ovlasti na namjenskoj bazi podataka:

$ GRANT ALL ON <database>.* TO '<username'@'%';

1	$ GRANT ALL ON <database>.* TO '<username'@'%';

Promjena Django konfiguracije za korištenje MySQL-a

Sada moramo prilagoditi neke Django konfiguracije kako bi mogao koristiti MySQL kao poslužitelj baze podataka. Otvorite settings.py u uređivaču teksta:

$ nano settings.py

1	$ nano settings.py

Pomaknite se dolje do odjeljka DATABASES i zalijepite sljedeći kod:

DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'OPTIONS': {
'read_default_file': '/etc/mysql/my.cnf',
},
}
}

DATABASES = {

'default': {

'ENGINE': 'django.db.backends.mysql',

'OPTIONS': {

'read_default_file': '/etc/mysql/my.cnf',

}

Zatim uredite MySQL konfiguracijsku datoteku tako da sadrži potrebne vjerodajnice baze podataka:

$ sudo nano /etc/mysql/my.cnf

1	$ sudo nano /etc/mysql/my.cnf

Dodajte sljedeći blok na kraj datoteke:

[client]
database = <dedicated_database>
user = <dedicated_user>
password = <user_password>
default-character-set = utf8

[client]

database = <dedicated_database>

user = <dedicated_user>

password = <user_password>

default-character-set = utf8

Ponovno pokrenite MySQL kako bi promjene stupile na snagu:

$ sudo systemctl daemon-reload
$ sudo systemctl restart mysql

1 2	$ sudo systemctl daemon-reload $ sudo systemctl restart mysql

Korak 6. Stvaranje Django modela

Sada smo spremni stvoriti novi model unutar našeg Django projekta. Aktivirajte virtualno okruženje:

$ cd sample_app/
$ . sample_app_env/bin/activate
$ cd sample_app/

$ cd sample_app/

$ . sample_app_env/bin/activate

$ cd sample_app/

Na ovoj lokaciji, recite Djangu da stvori novu aplikaciju:

$ python manage.py startapp <new_app>

1	$ python manage.py startapp <new_app>

Nakon stvaranja, stablo datoteka trebalo bi izgledati otprilike ovako. Ovdje će datoteka models.py sadržavati kodove za naš prilagođeni Django model:

Provjerite trenutni sadržaj datoteke:

$ cat models.py

1	$ cat models.py

Za demonstraciju, stvorit ćemo model za objave na blogu pod nazivom Post. Sadržavat će sljedeća polja:

title: Naslov objave na blogu.
slug: Pohranjuje i generira valjane URL-ove za web stranice.
content: Tekst objave na blogu.
created_on: Datum stvaranja objave.
author: Korisnik koji je stvorio objavu.

Otvorite datoteku models.py u uređivaču teksta:

$ nano models.py

1	$ nano models.py

Uvezimo neke potrebne API-je za naš model. Prema zadanim postavkama, uvozi se models API. Također će nam trebati slugify API za generiranje slugova, User za autentifikaciju i reverse za bolje i fleksibilnije stvaranje URL-ova:

from django.db import models
from django.template.defaultfilters import slugify
from django.contrib.auth.models import User
from django.urls import reverse

from django.db import models

from django.template.defaultfilters import slugify

from django.contrib.auth.models import User

from django.urls import reverse

Zatim dodajte metodu klase pod nazivom Post. Sadržavat će potrebna polja baze podataka kao što su title, slug, content, created_on, i author:

class Post(models.Model):
   title = models.CharField(max_length=255)
   slug = models.SlugField(unique=True, max_length=255)
   content = models.TextField()
   created_on = models.DateTimeField(auto_now_add=True)
   author = models.TextField()

class Post(models.Model):

title = models.CharField(max_length=255)

slug = models.SlugField(unique=True, max_length=255)

content = models.TextField()

created_on = models.DateTimeField(auto_now_add=True)

author = models.TextField()

Trebamo funkcionalnost za generiranje URL-a i spremanje objave. To je važno jer generira jedinstvene poveznice koje odgovaraju jedinstvenim objavama:

def get_absolute_url(self):
   return reverse('blog_post_detail', args=[self.slug])

def save(self, *args, **kwargs):
   if not self.slug:
      self.slug = slugify(self.title)
      super(Post, self).save(*args, **kwargs)

def get_absolute_url(self):

return reverse('blog_post_detail', args=[self.slug])

def save(self, *args, **kwargs):

if not self.slug:

self.slug = slugify(self.title)

super(Post, self).save(*args, **kwargs)

Sljedeći odjeljak će modelu reći kako poredati objave i prikazati ih na web stranici. Kodirat ćemo logiku koristeći unutarnju klasu, Meta. Sadržat će dodatnu logiku modela koja se ne tiče definicije polja baze podataka:

class Meta:
   ordering = ['created_on']

def __unicode__(self):
   return self.title

class Meta:

ordering = ['created_on']

def __unicode__(self):

return self.title

Naposljetku, imat ćemo značajku Comment modela u ovoj datoteci. Zahtijeva dodavanje još jedne klase Comment koristeći models.Model kao njezin potpis. Sadržat će sljedeća polja baze podataka:

name: Ime komentatora.
email: E-adresa komentatora.
text: Sadržaj samog komentara.
post: Objava na kojoj je komentar ostavljen.
created_on: Vrijeme stvaranja komentara.

Kod će izgledati otprilike ovako:

class Comment(models.Model): 
   name = models.CharField(max_length=42) 
   email = models.EmailField(max_length=75) 
   website = models.URLField(max_length=200, null=True, blank=True) 
   content = models.TextField() 
   post = models.ForeignKey(Post, on_delete=models.CASCADE) 
   created_on = models.DateTimeField(auto_now_add=True)

class Comment(models.Model):

name = models.CharField(max_length=42)

email = models.EmailField(max_length=75)

website = models.URLField(max_length=200, null=True, blank=True)

content = models.TextField()

post = models.ForeignKey(Post, on_delete=models.CASCADE)

created_on = models.DateTimeField(auto_now_add=True)

U ovom trenutku, naša models.py datoteka će izgledati ovako:

Na kraju, spremite datoteku i zatvorite uređivač.

Korak 7. Ažuriranje Django postavki

Model je stvoren. Međutim, moramo prilagoditi neke konfiguracijske datoteke kako bismo model stavili u funkciju. Unutar settings.py, moramo dodati naš model pod INSTALLED_APPS.

Otvorite settings.py u uređivaču teksta:

$ nano settings.py

1	$ nano settings.py

Registrirajte novi modul pod odjeljkom INSTALLED_APPS:

Spremite datoteku i zatvorite uređivač.

Korak 8. Migracija promjena

Sada kada smo dodali sve željene modele, sljedeći korak je primjena tih promjena. Django će primijeniti ove sheme na našu MySQL bazu podataka.

Sljedeća naredba generirat će sve potrebne migracijske datoteke. Izlaz će prikazati lokacije svih tih datoteka unutar direktorija projekta:

$ python manage.py makemigrations

1	$ python manage.py makemigrations

Sljedeća naredba izlistat će sve postojeće migracije:

$ python manage.py showmigrations

1	$ python manage.py showmigrations

Imajte na umu da su sve migracije označene osim 0001_initial koja je stvorena kao dio modela Post i Comment.

Sljedeća naredba prikazat će koji će SQL upit Django izvršiti za provođenje migracija:

$ python manage.py sqlmigrate random_app 0001_initial

1	$ python manage.py sqlmigrate random_app 0001_initial

Sve što sada trebamo je primijeniti migracije. Ove migracije će zapisati promjene u bazu podataka:

$ python manage.py migrate

1	$ python manage.py migrate

Step 9. Verifying Changes

To verify the changes, let’s have a look at our MySQL database. Start the MySQL shell as the Django user:

$ mysql sample_app_data -u sample_app_user

1	$ mysql sample_app_data -u sample_app_user

Next, change the current active database to the Django app database:

$ USE <django_dedicated_database>;

1	$ USE <django_dedicated_database>;

List all the tables from the database:

$ SHOW TABLES;

1	$ SHOW TABLES;

Lastly, to see the content of any of the tables, use the DESCRIBE query:

$ DESCRIBE random_app_comment;
$ DESCRIBE random_app_post;

1 2	$ DESCRIBE random_app_comment; $ DESCRIBE random_app_post;

Django Limitations with MySQL

When using MySQL as the database server for your Django app, there are a few things to keep in mind:

There’s not much support for transactions around schema-altering processes. Meaning, if a migration fails, it requires manually unpicking all the changes before trying another migration. There’s no way to roll back to an earlier point when the failed migration didn’t take place.
For most of the schema-altering processes, MySQL completely rewrites tables. In certain situations, it can be really time-consuming. At worst, the time complexity will be proportional to the number of rows to be added or columns to be removed. According to the official Django documentation, it could take one minute per million rows.
MySQL enforces a character limit for the name lengths of columns, tables, and indices. There’s also a limit on the total size of all columns and index covers. Django can go higher than the limit. Some backends other than MySQL can handle the higher limit of Django.

That’s why it’s strongly recommended to weigh your options and choose the appropriate one.

Final Thoughts

This guide successfully demonstrates how to add modules to an existing Django app. We used MySQL as the backend for the app. It also showcases some key Django concepts like models, how migration works, and how Django translates models into MySQL database tables.

Happy Computing!

Hark Labs

Autor · CloudSigma

Preslav Dobrev je kreativni dizajner u CloudSigma, usredotočen na dosljedan poslovni identitet korištenjem tradicionalnih i inovativnih marketinških kanala. Vješt je u spajanju umjetničke vizije sa strateškim marketingom kako bi stvorio dojmljive brendirane priče.