Django-modellen maken: een tutorial

Hark Labs2022-03-08 · 12 min read

Django is een bekend webframework voor de snelle ontwikkeling van veilige en onderhoudbare websites en webapps. Gebouwd met Python, vereenvoudigt Django webontwikkeling, waardoor er meer tijd en focus is voor het schrijven van apps zonder telkens het wiel opnieuw uit te hoeven vinden. Django is een gratis en open-source project met robuuste officiële documentatie, geweldige community-ondersteuning en tal van gratis en betaalde ondersteuning.

In deze gids duiken we in het maken van Django-modellen. In Django is een model de belangrijkste bron van informatie over uw gegevens. Modellen beschrijven de velden en het gedrag van de op te slaan gegevens. Django gebruikt het model om de databasetabellen te genereren met behulp van ORM (Object Relational Mapping), ook wel modellen genoemd.

Vereisten

We werken op een op Unix gebaseerd besturingssysteem, bij voorkeur een Ubuntu 20.04 cloudserver als het systeem waarop we hebben getest. Als u Django op een vergelijkbare omgeving wilt instellen, raadpleeg dan onze handleiding, “Hoe Django te installeren en een ontwikkelomgeving in te richten op Ubuntu 20.04.”

Stap 1. Python-ontwikkelomgeving

Django is gebouwd op Python. We hebben dus een robuuste Python-ontwikkelomgeving nodig met alle benodigde tools om met Python-apps te werken. We hebben dit al besproken in een speciale gids. Hier geven we een korte demonstratie.

Start eerst een terminal en voer de volgende commando's uit:

$ 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

Installeer vervolgens pip – de Python-pakketbeheerder:

$ sudo apt install python3-pip

1	$ sudo apt install python3-pip

Installeer vervolgens enkele aanvullende ontwikkelingspakketten:

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

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

Om een virtuele omgeving op te zetten, hebben we ook de Python-venv-module nodig:

$ sudo apt install python3-venv

1	$ sudo apt install python3-venv

Stap 2. MySQL-server installeren

MySQL is een populair relationeel databasebeheersysteem. Het is open-source, stadiel en rijk aan functies. We gebruiken MySQL als de databaseserver voor onze Django-app. Installeer MySQL met behulp van APT:

$ sudo apt install mysql-server

1	$ sudo apt install mysql-server

Controleer vervolgens de installatie:

$ systemctl status mysql

1	$ systemctl status mysql

Dit is slechts een basisinstallatie van MySQL met standaardopties. Bekijk de meer diepgaande gids over MySQL-installatie en -configuratie.

Stap 3. De Django-app instellen

We zijn nu klaar om onze Django-app te maken. Als u geïnteresseerd bent in een verdere diepgaande demonstratie van Django, raadpleeg dan onze handleiding, “Het Django-webframework installeren op Ubuntu 20.04.”

Maak vervolgens een speciale map aan voor de app. De mapnaam moet de projectnaam weerspiegelen:

$ mkdir -pv <project_dir>

1	$ mkdir -pv <project_dir>

Maak binnen de projectmap een virtuele Python-omgeving aan met behulp van de venv-module:

$ python3 -m venv <virtual_env_name>

1	$ python3 -m venv <virtual_env_name>

Activeer de virtuele omgeving:

$ . sample_app_env/bin/activate

1	$ . sample_app_env/bin/activate

Installeer Django met behulp van pip:

$ pip install django

1	$ pip install django

Maak vervolgens een nieuw Django-project aan met behulp van het django-admin-commando:

$ django-admin startproject sample_app

1	$ django-admin startproject sample_app

Stap 4. De Django-app configureren

De Django-app bevat alle standaardconfiguraties. Voor ons doel moeten we enkele aanpassingen doen.

Begin met het bewerken van het configuratiebestand settings.py:

$ nano sample_app/sample_app/sample_app/settings.py

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

Wijzig vervolgens de tijdzone:

$ TIME_ZONE = '<time_zone>'

1	$ TIME_ZONE = '<time_zone>'

Voeg de machines toe die toegang mogen hebben tot de Django-appserver:

$ ALLOWED_HOSTS = ['<allowed_host_ip_or_domain_name >']

1	$ ALLOWED_HOSTS = ['<allowed_host_ip_or_domain_name >']

Pas daarna de wijzigingen toe:

$ python manage.py migrate

1	$ python manage.py migrate

Maak ten slotte een superuser aan voor onze Django-webapp:

$ python manage.py createsuperuser

1	$ python manage.py createsuperuser

Stap 5. Django-app verbinden met MySQL

Om verbinding te maken met MySQL hebben we een extra Python-connectorbibliotheek nodig die compatibel is met Django. We gebruiken mysqlclient.

Zorg er eerst voor dat de benodigde pakketten zijn geïnstalleerd:

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

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

Installeer vervolgens mysqlclient:

$ pip install mysqlclient

1	$ pip install mysqlclient

Een specifieke database aanmaken

Voor onze app moeten we een specifieke database en databasegebruiker aanmaken. Start de MySQL-shell als root:

$ sudo mysql -u root

1	$ sudo mysql -u root

Maak een specifieke database aan voor onze Django-app:

$ CREATE DATABASE <dedicated_database>;

1	$ CREATE DATABASE <dedicated_database>;

Maak vervolgens een specifieke databasegebruiker aan voor de Django-app:

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

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

Verleen ten slotte de specifieke gebruiker volledige rechten op de specifieke database:

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

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

Django-configuratie wijzigen om MySQL te gebruiken

Nu moeten we enkele Django-configuraties aanpassen zodat het MySQL als databaseserver kan gebruiken. Open settings.py in een teksteditor:

$ nano settings.py

1	$ nano settings.py

Scrol omlaag naar de sectie DATABASES en plak de volgende code:

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',

}

Bewerk vervolgens het MySQL-configuratiebestand zodat het de benodigde databasegegevens bevat:

$ sudo nano /etc/mysql/my.cnf

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

Voeg het volgende blok toe aan het einde van het bestand:

[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

Start MySQL opnieuw op om de wijzigingen door te voeren:

$ sudo systemctl daemon-reload
$ sudo systemctl restart mysql

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

Step 6. Creating a Django Model

We zijn nu klaar om een nieuw model aan te maken binnen ons Django-project. Activeer de virtuele omgeving:

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

$ cd sample_app/

$ . sample_app_env/bin/activate

$ cd sample_app/

Laat Django op deze locatie een nieuwe app aanmaken:

$ python manage.py startapp <new_app>

1	$ python manage.py startapp <new_app>

Na het aanmaken zou de mappenstructuur er ongeveer zo uit moeten zien. Hier zal het bestand models.py de code bevatten voor ons aangepaste Django-model:

Controleer de huidige inhoud van het bestand:

$ cat models.py

1	$ cat models.py

Ter demonstratie gaan we een model maken voor blogberichten met de naam Post. Het zal de volgende velden bevatten:

title: Titel van het blogbericht.
slug: Slaat geldige URL's op en genereert deze voor webpagina's.
content: De tekst van het blogbericht.
created_on: Datum waarop het bericht is aangemaakt.
author: De gebruiker die het bericht heeft aangemaakt.

Open het bestand models.py in een teksteditor:

$ nano models.py

1	$ nano models.py

Laten we enkele benodigde API's importeren voor ons model. Standaard importeert het de models-API. We hebben ook de slugify-API nodig voor het genereren van slugs, User voor authenticatie, en reverse voor een betere en flexibelere URL-creatie:

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

Voeg vervolgens de class-methode genaamd Post toe. Deze zal de benodigde databasevelden bevatten zoals title, slug, content, created_on, and 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()

We hebben de functionaliteit nodig voor het genereren van URL's en het opslaan van het bericht. Dit is belangrijk omdat het unieke links genereert die overeenkomen met unieke berichten:

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)

In de volgende sectie vertellen we het model hoe het bericht gesorteerd moet worden en hoe het op de webpagina moet worden weergegeven. We coderen de logica met behulp van een inner class, Meta. Deze zal aanvullende modellogica bevatten die geen betrekking heeft op de definitie van de databasevelden:

class Meta:
   ordering = ['created_on']

def __unicode__(self):
   return self.title

class Meta:

ordering = ['created_on']

def __unicode__(self):

return self.title

Ten slotte hebben we de functionaliteit van het Comment-model in dit bestand. Dit vereist het toevoegen van nog een klasse Comment met behulp van models.Model als signatuur. Deze zal de volgende databasevelden bevatten:

name: Naam van de reageerder.
email: E-mailadres van de reageerder.
text: Inhoud van de reactie zelf.
post: Het bericht waarop de reactie is geplaatst.
created_on: Tijdstip waarop de reactie is aangemaakt.

De code zal er ongeveer zo uitzien:

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)

Op dit moment zal ons models.py-bestand er zo uitzien:

Sla ten slotte het bestand op en sluit de editor.

Stap 7. Django-instellingen bijwerken

Het model is gemaakt. We moeten echter enkele configuratiebestanden aanpassen om het model in werking te stellen. In settings.py, moeten we ons model toevoegen onder INSTALLED_APPS.

Open settings.py in een teksteditor:

$ nano settings.py

1	$ nano settings.py

Registreer de nieuwe module onder de sectie INSTALLED_APPS:

Sla het bestand op en sluit de editor.

Stap 8. Wijzigingen migreren

Nu we alle gewenste modellen hebben toegevoegd, is de volgende stap het toepassen van deze wijzigingen. Django zal deze schema's toepassen op onze MySQL-database.

Het volgende commando genereert alle benodigde migratiebestanden. De uitvoer toont de locaties van al die bestanden binnen de projectmap:

$ python manage.py makemigrations

1	$ python manage.py makemigrations

Het volgende commando toont een lijst van alle bestaande migraties:

$ python manage.py showmigrations

1	$ python manage.py showmigrations

Let op dat alle migraties zijn gemarkeerd, behalve 0001_initial die is gemaakt als onderdeel van de modellen Post en Comment.

Het volgende commando laat zien welke SQL-query Django zal uitvoeren om de migraties uit te voeren:

$ python manage.py sqlmigrate random_app 0001_initial

1	$ python manage.py sqlmigrate random_app 0001_initial

Het enige wat we nu nog hoeven te doen is de migraties toepassen. Deze migraties zullen de wijzigingen in de database wegschrijven:

$ python manage.py migrate

1	$ python manage.py migrate

Stap 9. Wijzigingen verifiëren

Om de wijzigingen te verifiëren, nemen we een kijkje in onze MySQL-database. Start de MySQL-shell als de Django-gebruiker:

$ mysql sample_app_data -u sample_app_user

1	$ mysql sample_app_data -u sample_app_user

Wijzig vervolgens de huidige actieve database naar de Django-app-database:

$ USE <django_dedicated_database>;

1	$ USE <django_dedicated_database>;

Toon een lijst van alle tabellen in de database:

$ SHOW TABLES;

1	$ SHOW TABLES;

Gebruik ten slotte de DESCRIBE query:

$ DESCRIBE random_app_comment;
$ DESCRIBE random_app_post;

1 2	$ DESCRIBE random_app_comment; $ DESCRIBE random_app_post;

Django-beperkingen met MySQL

Wanneer u MySQL gebruikt als de databaseserver voor uw Django-app, zijn er een paar dingen waar u rekening mee moet houden:

Er is weinig ondersteuning voor transacties rond schema-wijzigende processen. Dit betekent dat als een migratie mislukt, alle wijzigingen handmatig ongedaan moeten worden gemaakt voordat u een andere migratie probeert. Er is geen manier om terug te rollen naar een eerder moment waarop de mislukte migratie nog niet had plaatsgevonden.
Voor de meeste schema-wijzigende processen herschrijft MySQL tabellen volledig. In bepaalde situaties kan dit erg tijdrovend zijn. In het ergste geval is de tijdscomplexiteit evenredig met het aantal toe te voegen rijen of te verwijderen kolommen. Volgens de officiële Django-documentatie kan het één minuut per miljoen rijen duren.
MySQL handhaaft een limiet voor het aantal tekens voor de lengte van kolom-, tabel- en indexnamen. Er is ook een limiet op de totale grootte van alle kolommen en indexen. Django kan deze limiet overschrijden. Sommige andere backends dan MySQL kunnen de hogere limiet van Django wel aan.

Daarom wordt het ten zeerste aanbevolen om uw opties af te wegen en de juiste te kiezen.

Laatste overwegingen

Deze handleiding laat succesvol zien hoe u modules toevoegt aan een bestaande Django-app. We hebben MySQL gebruikt als backend voor de app. Het toont ook enkele belangrijke Django-concepten zoals modellen, hoe migratie werkt en hoe Django modellen vertaalt naar MySQL-databasetabellen.

Veel computerplezier!

Hark Labs

Auteur · CloudSigma

Preslav Dobrev is een creatief ontwerper bij CloudSigma, met de nadruk op een consistente bedrijfsidentiteit door middel van traditionele en innovatieve marketingkanalen. Hij is bedreven in het samenvoegen van artistieke visie met strategische marketing om impactvolle merkverhalen te creëren.