Erstellen von Django-Modellen: Ein Tutorial

Hark Labs2022-03-08 · 12 min read

Erstellen von Django-Modellen: Ein Tutorial

Django ist ein bekanntes Web-Framework für die schnelle Entwicklung sicherer und wartbarer Websites und Web-Apps. Erstellt mit Python, vereinfacht Django die Webentwicklung und ermöglicht es, mehr Zeit und Fokus auf das Schreiben von Apps zu legen, ohne das Rad jedes Mal neu zu erfinden. Django ist ein freies und quelloffenes Projekt mit einer robusten offiziellen Dokumentation, großartiger Community-Unterstützung und viel freiem sowie kostenpflichtigem Support.

In dieser Anleitung befassen wir uns mit der Erstellung von Django-Modellen. In Django ist ein Modell die wichtigste Informationsquelle über Ihre Daten. Modelle beschreiben die Felder und das Verhalten der zu speichernden Daten. Django verwendet das Modell, um die Datenbanktabellen mittels ORM (Object Relational Mapping) zu generieren, die ebenfalls als Modelle bezeichnet werden.

Voraussetzungen

Wir arbeiten auf einem Unix-basierten Betriebssystem, vorzugsweise einem Ubuntu 20.04 Cloud-Server als dem System, auf dem wir getestet haben. Wenn Sie Django in einer ähnlichen Umgebung einrichten möchten, lesen Sie bitte unser Tutorial „Wie man Django installiert und eine Entwicklungsumgebung auf Ubuntu 20.04 einrichtet.”

Schritt 1. Python-Entwicklungsumgebung

Django basiert auf Python. Daher benötigen wir eine robuste Python-Entwicklungsumgebung mit allen notwendigen Werkzeugen, um mit Python-Apps zu arbeiten. Wir haben dies bereits in einer speziellen Anleitung besprochen. Hier zeigen wir eine kurze Demonstration.

Starten Sie zuerst ein Terminal und führen Sie die folgenden Befehle aus:

$ 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

Installieren Sie als Nächstes pip – den Python-Paketmanager:

$ sudo apt install python3-pip

1	$ sudo apt install python3-pip

Installieren Sie dann einige zusätzliche Entwicklungspakete:

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

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

Um eine virtuelle Umgebung einzurichten, benötigen wir auch das Python-venv-Modul:

$ sudo apt install python3-venv

1	$ sudo apt install python3-venv

Schritt 2. Installieren des MySQL-Servers

MySQL ist ein beliebtes relationales Datenbankverwaltungssystem. Es ist Open-Source, stabil und funktionsreich. Wir werden MySQL als Datenbankserver für unsere Django-App verwenden. Installieren Sie MySQL über APT:

$ sudo apt install mysql-server

1	$ sudo apt install mysql-server

Überprüfen Sie als Nächstes die Installation:

$ systemctl status mysql

1	$ systemctl status mysql

Dies ist nur eine minimale Einrichtung von MySQL mit Standardoptionen. Weitere Informationen finden Sie in der ausführlicheren Anleitung zur Installation und Konfiguration von MySQL.

Schritt 3. Einrichten der Django-App

Wir sind nun bereit, unsere Django-App zu erstellen. Wenn Sie an einer weiteren ausführlichen Demonstration von Django interessiert sind, lesen Sie bitte unser Tutorial „Installation des Django-Web-Frameworks auf Ubuntu 20.04.”

Erstellen Sie als Nächstes ein eigenes Verzeichnis für die App. Der Verzeichnisname sollte den Projektnamen widerspiegeln:

$ mkdir -pv <project_dir>

1	$ mkdir -pv <project_dir>

Erstellen Sie im Projektverzeichnis eine virtuelle Python-Umgebung mit dem venv-Modul:

$ python3 -m venv <virtual_env_name>

1	$ python3 -m venv <virtual_env_name>

Aktivieren Sie die virtuelle Umgebung:

$ . sample_app_env/bin/activate

1	$ . sample_app_env/bin/activate

Installieren Sie Django mit pip:

$ pip install django

1	$ pip install django

Erstellen Sie als Nächstes ein neues Django-Projekt mit dem Befehl django-admin:

$ django-admin startproject sample_app

1	$ django-admin startproject sample_app

Schritt 4. Konfigurieren der Django-App

Die Django-App enthält alle Standardkonfigurationen. Für unser Ziel müssen wir einige Anpassungen vornehmen.

Beginnen Sie mit der Bearbeitung der Konfigurationsdatei settings.py:

$ nano sample_app/sample_app/sample_app/settings.py

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

Ändern Sie dann die Zeitzone:

$ TIME_ZONE = '<time_zone>'

1	$ TIME_ZONE = '<time_zone>'

Fügen Sie die Rechner hinzu, die auf den Django-App-Server zugreifen dürfen:

$ ALLOWED_HOSTS = ['<allowed_host_ip_or_domain_name >']

1	$ ALLOWED_HOSTS = ['<allowed_host_ip_or_domain_name >']

Wenden Sie danach die Änderungen an:

$ python manage.py migrate

1	$ python manage.py migrate

Erstellen Sie schließlich einen Superuser für unsere Django-Web-App:

$ python manage.py createsuperuser

1	$ python manage.py createsuperuser

Schritt 5. Django-App mit MySQL verbinden

Um eine Verbindung zu MySQL herzustellen, benötigen wir eine zusätzliche Python-Connector-Bibliothek, die mit Django kompatibel ist. Wir verwenden mysqlclient.

Stellen Sie zunächst sicher, dass die erforderlichen Pakete installiert sind:

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

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

Installieren Sie als Nächstes mysqlclient:

$ pip install mysqlclient

1	$ pip install mysqlclient

Erstellen einer dedizierten Datenbank

Für unsere App müssen wir eine dedizierte Datenbank und einen Datenbankbenutzer erstellen. Starten Sie die MySQL-Shell als root:

$ sudo mysql -u root

1	$ sudo mysql -u root

Erstellen Sie eine dedizierte Datenbank für unsere Django-App:

$ CREATE DATABASE <dedicated_database>;

1	$ CREATE DATABASE <dedicated_database>;

Erstellen Sie anschließend einen dedizierten Datenbankbenutzer für die 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>';

Erteilen Sie dem dedizierten Benutzer schließlich die vollen Berechtigungen für die dedizierte Datenbank:

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

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

Django-Konfiguration zur Verwendung von MySQL ändern

Jetzt müssen wir einige Django-Konfigurationen anpassen, damit MySQL als Datenbankserver verwendet werden kann. Öffnen Sie settings.py in einem Texteditor:

$ nano settings.py

1	$ nano settings.py

Scrollen Sie nach unten zum Abschnitt DATABASES und fügen Sie den folgenden Code ein:

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

}

Bearbeiten Sie als Nächstes die MySQL-Konfigurationsdatei, sodass sie die erforderlichen Datenbank-Anmeldedaten enthält:

$ sudo nano /etc/mysql/my.cnf

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

Fügen Sie am Ende der Datei den folgenden Block hinzu:

[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

Starten Sie MySQL neu, damit die Änderungen wirksam werden:

$ sudo systemctl daemon-reload
$ sudo systemctl restart mysql

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

Schritt 6. Erstellen eines Django-Modells

Wir sind nun bereit, ein neues Modell in unserem Django-Projekt zu erstellen. Aktivieren Sie die virtuelle Umgebung:

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

$ cd sample_app/

$ . sample_app_env/bin/activate

$ cd sample_app/

Weisen Sie Django an dieser Stelle an, eine neue App zu erstellen:

$ python manage.py startapp <new_app>

1	$ python manage.py startapp <new_app>

Nach dem Erstellen sollte die Dateistruktur in etwa so aussehen. Hier wird die Datei models.py den Code für unser benutzerdefiniertes Django-Modell enthalten:

Überprüfen Sie den aktuellen Inhalt der Datei:

$ cat models.py

1	$ cat models.py

Zur Demonstration erstellen wir ein Modell für Blogbeiträge namens Post. Es wird die folgenden Felder enthalten:

title: Titel des Blogbeitrags.
slug: Speichert und generiert gültige URLs für Webseiten.
content: Der Text des Blogbeitrags.
created_on: Erstellungsdatum des Beitrags.
author: Der Benutzer, der den Beitrag erstellt hat.

Öffnen Sie die Datei models.py in einem Texteditor:

$ nano models.py

1	$ nano models.py

Importieren wir einige erforderliche APIs für unser Modell. Standardmäßig wird die models-API importiert. Wir benötigen außerdem die slugify-API zum Generieren von Slugs, User für die Authentifizierung und reverse für eine bessere und flexiblere URL-Erstellung:

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

Fügen Sie als Nächstes die Klassenmethode namens Post. Sie wird die erforderlichen Datenbankfelder enthalten, wie title, slug, content, created_on, und 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()

Wir benötigen die Funktionalität für die URL-Generierung und das Speichern des Beitrags. Dies ist wichtig, da dadurch eindeutige Links generiert werden, die zu eindeutigen Beiträgen passen:

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)

Der nächste Abschnitt teilt dem Modell mit, wie der Beitrag sortiert und auf der Webseite angezeigt werden soll. Wir werden die Logik mithilfe einer inneren Klasse codieren, Meta. Sie wird zusätzliche Modelllogik enthalten, die nicht die Definition der Datenbankfelder betrifft:

class Meta:
   ordering = ['created_on']

def __unicode__(self):
   return self.title

class Meta:

ordering = ['created_on']

def __unicode__(self):

return self.title

Schließlich werden wir die Funktion des Comment-Modells in dieser Datei haben. Dies erfordert das Hinzufügen einer weiteren Klasse Comment unter Verwendung von models.Model als Signatur. Sie wird die folgenden Datenbankfelder enthalten:

name: Name des Kommentators.
email: E-Mail-Adresse des Kommentators.
text: Inhalt des Kommentars selbst.
post: Der Beitrag, zu dem der Kommentar verfasst wurde.
created_on: Zeitpunkt der Erstellung des Kommentars.

Der Code wird in etwa so aussehen:

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)

Zu diesem Zeitpunkt wird unsere models.py-Datei so aussehen:

Speichern Sie abschließend die Datei und schließen Sie den Editor.

Schritt 7. Aktualisieren der Django-Einstellungen

Das Modell ist erstellt. Wir müssen jedoch einige Konfigurationsdateien anpassen, um das Modell in Betrieb zu nehmen. In settings.py müssen wir unser Modell unter INSTALLED_APPS.

Öffnen Sie settings.py in einem Texteditor:

$ nano settings.py

1	$ nano settings.py

Registrieren Sie das neue Modul im Abschnitt INSTALLED_APPS:

Speichern Sie die Datei und schließen Sie den Editor.

Schritt 8. Migration von Änderungen

Nachdem wir nun alle gewünschten Modelle hinzugefügt haben, besteht der nächste Schritt darin, diese Änderungen anzuwenden. Django wird diese Schemata auf unsere MySQL-Datenbank anwenden.

Der folgende Befehl generiert alle erforderlichen Migrationsdateien. Die Ausgabe zeigt die Speicherorte all dieser Dateien im Projektverzeichnis an:

$ python manage.py makemigrations

1	$ python manage.py makemigrations

Der folgende Befehl listet alle vorhandenen Migrationen auf:

$ python manage.py showmigrations

1	$ python manage.py showmigrations

Beachten Sie, dass alle Migrationen markiert sind, außer 0001_initial, die als Teil der Modelle Post und Comment.

Der folgende Befehl zeigt, welche SQL-Abfrage Django ausführen wird, um die Migrationen durchzuführen:

$ python manage.py sqlmigrate random_app 0001_initial

1	$ python manage.py sqlmigrate random_app 0001_initial

Alles, was wir jetzt tun müssen, ist, die Migrationen anzuwenden. Diese Migrationen schreiben die Änderungen in die Datenbank:

$ python manage.py migrate

1	$ python manage.py migrate

Schritt 9. Änderungen überprüfen

Um die Änderungen zu überprüfen, werfen wir einen Blick auf unsere MySQL-Datenbank. Starten Sie die MySQL-Shell als Django-Benutzer:

$ mysql sample_app_data -u sample_app_user

1	$ mysql sample_app_data -u sample_app_user

Wechseln Sie als Nächstes die aktuell aktive Datenbank zur Django-App-Datenbank:

$ USE <django_dedicated_database>;

1	$ USE <django_dedicated_database>;

Listen Sie alle Tabellen aus der Datenbank auf:

$ SHOW TABLES;

1	$ SHOW TABLES;

Verwenden Sie schließlich, um den Inhalt einer der Tabellen anzuzeigen, die DESCRIBE-Abfrage:

$ DESCRIBE random_app_comment;
$ DESCRIBE random_app_post;

1 2	$ DESCRIBE random_app_comment; $ DESCRIBE random_app_post;

Django-Einschränkungen bei MySQL

Wenn Sie MySQL als Datenbankserver für Ihre Django-App verwenden, gibt es einige Dinge zu beachten:

Es gibt kaum Unterstützung für Transaktionen bei schemaverändernden Prozessen. Das bedeutet, wenn eine Migration fehlschlägt, müssen alle Änderungen manuell rückgängig gemacht werden, bevor eine andere Migration versucht werden kann. Es gibt keine Möglichkeit, zu einem früheren Zeitpunkt zurückzukehren, an dem die fehlgeschlagene Migration noch nicht stattgefunden hat.
Bei den meisten schemaverändernden Prozessen schreibt MySQL Tabellen komplett neu. In bestimmten Situationen kann dies sehr zeitaufwendig sein. Im schlimmsten Fall ist die Zeitkomplexität proportional zur Anzahl der hinzuzufügenden Zeilen oder zu entfernenden Spalten. Laut der offiziellen Django-Dokumentation kann dies eine Minute pro Million Zeilen dauern.
MySQL erzwingt eine Zeichenbegrenzung für die Namenslängen von Spalten, Tabellen und Indizes. Es gibt auch eine Begrenzung für die Gesamtgröße aller Spalten und Index-Abdeckungen. Django kann dieses Limit überschreiten. Einige andere Backends als MySQL können mit dem höheren Limit von Django umgehen.

Aus diesem Grund wird dringend empfohlen, Ihre Optionen abzuwägen und die passende auszuwählen.

Schlussgedanken

Diese Anleitung zeigt erfolgreich, wie Sie Module zu einer bestehenden Django-App hinzufügen. Wir haben MySQL als Backend für die App verwendet. Sie zeigt auch einige wichtige Django-Konzepte wie Modelle, wie Migrationen funktionieren und wie Django Modelle in MySQL-Datenbanktabellen übersetzt.

Viel Spaß beim Programmieren!

Hark Labs

Autor · CloudSigma

Preslav Dobrev ist ein kreativer Designer bei CloudSigma und konzentriert sich auf eine konsistente Unternehmensidentität durch traditionelle und innovative Marketingkanäle. Er versteht es meisterhaft, künstlerische Vision mit strategischem Marketing zu verbinden, um wirkungsvolle Markengeschichten zu schaffen.