So erstellen Sie eine Django-App und verbinden sie mit einer Datenbank

Einführung

Django ist ein kostenloses und Open-Source-Web-Framework, das in Python geschrieben ist. Dieses Tool ermöglicht Skalierbarkeit, Wiederverwendbarkeit und schnelle Entwicklung.

In diesem Tutorial lernen Sie, wie Sie die initiale Grundlage für eine Blog-Website mit Verbindungen zu einer MySQL-Datenbank einrichten. Dies umfasst das Erstellen der Skelettstruktur der Blog-Webanwendung mit django-admin, das Erstellen der MySQL-Datenbank und das Verbinden der Webanwendung mit der Datenbank.

Django stellt Ihnen eine Entwicklungsumgebung bereit, um an Ihrer Blog-Webanwendung zu arbeiten, aber Sie müssen weitere Schritte unternehmen, bevor Ihr Blog im Internet live geht.

Voraussetzungen

Um diesem Tutorial zu folgen, benötigen Sie:

• Einen Ubuntu 22.04-Server mit einem nicht-root sudo-fähigen Benutzer und einer Firewall. Befolgen Sie unsere Anleitung zum Einrichten eines Ubuntu 22.04-Initialservers, um dies einzurichten.
• MySQL wurde installiert, um als Datenbank zu dienen. Sie können dies einrichten, indem Sie unserem Tutorial folgen unter So installieren Sie MySQL unter Ubuntu 22.04.
• A Python environment set up. For this, follow our tutorial on How To Install Python 3 and Set Up a Programming Environment on Ubuntu 22.04
  .

Nachdem alles installiert und eingerichtet ist, können Sie zum ersten Schritt übergehen.

Schritt 1 – Datenbank erstellen

Django unterstützt eine Reihe beliebter Datenbankverwaltungssysteme, aber dieser Leitfaden konzentriert sich darauf, Django mit einer MySQL-Datenbank zu verbinden. Um dies zu tun, müssen Sie eine Datenbank auf Ihrer MySQL-Instanz erstellen sowie ein MySQL-Benutzerprofil, das Django zum Verbinden mit der Datenbank verwenden kann.

Um dies einzurichten, verbinden Sie sich mit Ihrer MySQL-Datenbank als der root-Benutzer von MySQL mit dem folgenden Befehl:

sudo mysql

Sie wissen, dass Sie im MySQL-Server sind, wenn sich der Prompt ändert:

Inspektieren Sie die aktuellen Datenbanken mit dem folgenden Befehl:

SHOW DATABASES;

Ihre Ausgabe wird ähnlich sein wie die folgende, vorausgesetzt, dass Sie noch keine Datenbanken erstellt haben:

Output
+--------------------+
| Database       	|
+--------------------+
| information_schema |
| mysql         	|
| performance_schema |
| sys            	|
+--------------------+
4 rows in set (0.00 sec)

Standardmäßig haben Sie bereits 4 Datenbanken erstellt: information_schema, MySQL, performance_schema und sys. Sie müssen diese nicht berühren, da sie wichtige Informationen für den MySQL-Server selbst enthalten.

Erstellen Sie stattdessen die erste Datenbank, die die Daten für Ihren Blog enthält.

Um eine Datenbank in MySQL zu erstellen, führen Sie den folgenden Befehl aus und verwenden Sie einen aussagekräftigen Namen für Ihre Datenbank:

CREATE DATABASE blog_data;

Nach erfolgreicher Erstellung der Datenbank lautet die Ausgabe wie folgt:

Output
Query OK, 1 row affected (0.00 sec)

Überprüfen Sie, ob die Datenbank nun als eine der verfügbaren Datenbanken aufgeführt ist:

SHOW DATABASES;

Die Datenbank blog_data sollte nun unter den in der Ausgabe enthaltenen Datenbanken aufgeführt sein:

Output
+--------------------+
| Database       	|
+--------------------+
| information_schema |
| blog_data      	|
| mysql             	|
| performance_schema |
| sys            	|
+--------------------+
5 rows in set (0.00 sec)

Erstellen Sie als nächstes ein separates MySQL-Benutzerkonto, das Django zum Betrieb der neuen Datenbank verwenden wird. Das Erstellen spezifischer Datenbanken und Konten kann aus Verwaltungs- und Sicherheitsgründen hilfreich sein. In diesem Leitfaden verwenden wir den Namen djangouser. Sie können jedoch einen beliebigen Namen verwenden, aber es kann hilfreich sein, einen beschreibenden Namen zu wählen.

Sie werden dieses Konto erstellen, ein Passwort festlegen und Zugriff auf die von Ihnen erstellte Datenbank gewähren. Erstellen Sie zunächst den Benutzer und setzen Sie sein Passwort, indem Sie den folgenden Befehl eingeben. Ersetzen Sie in diesem Beispiel password durch ein starkes Passwort für Ihre Datenbank:

CREATE USER 'djangouser'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';

Lassen Sie die Datenbank wissen, dass djangouser vollständigen Zugriff auf die von Ihnen eingerichtete Datenbank haben sollte:

GRANT ALL ON blog_data.* TO 'djangouser'@'localhost';

Sie haben nun eine Datenbank und ein Benutzerkonto, die jeweils speziell für Django erstellt wurden. Aktualisieren Sie die Berechtigungen, damit die aktuelle Instanz von MySQL über die von Ihnen vorgenommenen Änderungen informiert ist:

FLUSH PRIVILEGES;

Damit ist die Einrichtung abgeschlossen. Sie können den MySQL-Server verlassen, indem Sie EXIT; eingeben oder CTRL + D drücken.

Schritt 2 — Erstellen einer MySQL-Optionsdatei

Anstatt Ihre MySQL-Verbindungsdetails in der Django-Konfigurationsdatei anzugeben, können Sie sie in einer Optionsdatei speichern. Viele MySQL-Programme können Optionsdateien lesen — auch als Konfigurationsdateien bekannt — für Informationen wie Startoptionen oder Verbindungsdetails. Dies kann praktisch sein, da Sie Ihre Datenbankanmeldeinformationen nur an einem Ort speichern müssen.

Öffnen Sie die Konfigurationsdatei my.cnf mit Ihrem bevorzugten Texteditor, um Ihre MySQL-Anmeldeinformationen zu aktualisieren. Hier verwenden wir nano:

sudo nano /etc/mysql/my.cnf

Fügen Sie die folgenden Zeilen hinzu und fügen Sie Ihre relevanten Informationen ein:

…

[client]
database = blog_data
user = djangouser
password = your_actual_password
default-character-set = utf8

Beachten Sie, dass utf8 als Standardcodierung festgelegt ist. Dies ist eine häufige Methode zum Codieren von Unicode-Daten in MySQL. Wenn Sie sicher sind, dass Ihre Details korrekt sind, speichern Sie die Datei und schließen Sie sie. Wenn Sie nano zum Bearbeiten der Datei verwendet haben, können Sie dies tun, indem Sie STRG + O drücken, um die Datei zu speichern, und dann STRG + X, um den Editor zu schließen.

Nachdem die Datei bearbeitet wurde, starten Sie MySQL neu, damit die Änderungen wirksam werden:

sudo systemctl daemon-reload
sudo systemctl restart mysql

Beachten Sie, dass das Neustarten von MySQL einige Sekunden dauert, also bitte um Geduld.

Schritt 3 — Erstellen des Initialen Django-Projektgerüsts

In diesem Schritt legen Sie den Grundstein für Ihre Anwendung, indem Sie das Projektgerüst mit dem Befehl django-admin generieren.

Navigieren Sie zum Verzeichnis, in dem Sie Ihre Blog-Anwendung erstellen möchten. Innerhalb dieses Verzeichnisses erstellen Sie ein spezifisches Verzeichnis, um die Anwendung zu erstellen. Benennen Sie das Verzeichnis nach etwas Sinnvollem für die von Ihnen erstellte App. Als Beispiel nennen wir unseres my_blog_app:

mkdir my_blog_app

Navigieren Sie nun zum neu erstellten Verzeichnis:

cd my_blog_app

Wechseln Sie als nächstes in die Programmierumgebung, die Sie für die Arbeit mit Django verwenden möchten. Sie können eine bestehende verwenden oder eine neue erstellen. Der folgende Befehl erstellt eine neue Umgebung namens env, aber Sie sollten einen Namen verwenden, der für Sie sinnvoll ist:

python3 -m venv env

Sobald sie erstellt ist, können Sie sie aktivieren:

. env/bin/activate

Installieren Sie nun Django in diese Umgebung, falls Sie dies noch nicht getan haben:

pip install django

Während Sie sich im Verzeichnis my_blog_app befinden, generieren Sie ein Projekt, indem Sie den folgenden Befehl ausführen:

django-admin startproject blog

Überprüfen Sie, ob es funktioniert hat, indem Sie zum Verzeichnis blog/ navigieren:

cd blog

Führen Sie dann ls aus, um zu überprüfen, ob die erforderlichen Dateien und Verzeichnisse innerhalb des Projektordners erstellt wurden:

ls

Die Ausgabe listet das Verzeichnis blog und eine Datei manage.py auf:

Output
blog manage.py

Nun, da Sie ein Projektverzeichnis mit dem initialen Start Ihrer Blog-Anwendung erstellt haben, können Sie mit dem nächsten Schritt fortfahren.

Schritt 4 — Installation des MySQL-Datenbankconnectors

Um MySQL mit Ihrem Projekt zu verwenden, benötigen Sie eine Python 3-Datenbankconnector-Bibliothek, die mit Django kompatibel ist. Dieser Schritt erläutert, wie Sie einen solchen Datenbankconnector, mysqlclient, installieren, der eine verzweigte Version von MySQLdb ist.

Zuerst installieren Sie die notwendigen MySQL-Entwicklungs-Header und -Bibliotheken:

sudo apt install libmysqlclient-dev default-libmysqlclient-dev

Anschließend verwenden Sie pip, um das Paket wheel zu installieren. Wheel ist ein Verpackungsformat, das in Python verwendet wird, um Module aus dem Python Package Index zu installieren. Die Installation von Python-Programmen aus Wheel-Paketen ist im Allgemeinen schneller und ressourceneffizienter als das Erstellen von Paketen aus ihrem Quellcode. Um Programme zu installieren und mit ihnen zu arbeiten, die als Wheels verpackt sind, müssen Sie zunächst sicherstellen, dass das Paket wheel installiert ist:

pip install wheel

Fahren Sie dann mit der Installation von mysqlclient fort:

pip install mysqlclient

Ihre Ausgabe wird ähnlich wie folgt sein und bestätigt, dass der Client ordnungsgemäß installiert wurde:

Output
...
Successfully installed mysqlclient-2.1.1

Sie haben nun erfolgreich den MySQL-Client mithilfe der PyPi mysqlclient Connector-Bibliothek installiert.

Schritt 5 — Einstellungen bearbeiten

Als du zuvor django-admin ausgeführt hast, wurde eine Konfigurationsdatei für Django namens settings.py erstellt. Du musst einige der Standard-Einstellungen in dieser Datei ändern, um alles korrekt zum Laufen zu bringen.

Um die Datei zu bearbeiten, öffne den Pfad zur Datei mit deinem Texteditor deiner Wahl:

nano ~/my_blog_app/blog/blog/settings.py

Damit dein Blog die richtige Zeitzone hat, die mit deinem Gebiet verbunden ist, kannst du die settings.py-Datei bearbeiten, sodass sie deine aktuelle Zeitzone verwendet. Du kannst diese Liste der Zeitzonen als Referenz verwenden. Für unser Beispiel werden wir die Zeitzone America/New_York verwenden.

Innerhalb der Datei navigiere zum TIME_ZONE-Feld in der unteren Abschnitt der Datei:

...

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'UTC'

USE_I18N = True

USE_L10N = True

USE_TZ = True
...

Ändere die TIME_ZONE-Zeile, sodass sie auf deine aktuelle Zeitzone eingestellt ist. In diesem Beispiel verwenden wir die Zeitzone für New York:

...

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'America/New_York'

USE_I18N = True
...

Halte die Datei geöffnet, denn als nächstes musst du einen Pfad für deine statischen Dateien hinzufügen. Die Dateien, die von deiner Django-Webanwendung bereitgestellt werden, werden als statische Dateien bezeichnet. Dies könnte alle Dateien umfassen, die notwendig sind, um die vollständige Webseite darzustellen, einschließlich JavaScript, CSS und Bilder.

Gehe ans Ende der settings.py-Datei und füge STATIC_ROOT hinzu:

…

STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'static')
...

Nun, da Sie die Zeitzone und den Pfad für statische Dateien hinzugefügt haben, fügen Sie Ihre IP-Adresse zur Liste der erlaubten Hosts hinzu. Navigieren Sie zur Zeile der settings.py-Datei, wo es heißt ALLOWED_HOSTS, sie wird sich gegenüber dem oberen Teil der settings.py-Datei befinden. Fügen Sie Ihre Server-IP-Adresse, umgeben von einfachen Anführungszeichen, zwischen die eckigen Klammern ein:

...
ALLOWED_HOSTS = ['your_server_IP_address']
...

Als Nächstes fügen Sie das Python-Betriebssystemmodul hinzu, das verschiedene Funktionen für Verzeichnisse bereitstellt. Ohne dieses Modul erhalten Sie einen Fehler beim Einrichten des administrativen Benutzers, um die Django-Benutzeroberfläche zu verwenden. Um dies zu tun, müssen Sie das Modul os importieren, das auf Ihrem jeweiligen Betriebssystem funktionieren wird. Fügen Sie die Zeile import os über der Zeile from pathlib import Path ein:

...
import os
from pathlib import Path
...

Bisher haben Sie Ihre settings.py-Datei so bearbeitet, dass die richtige Zeitzone konfiguriert ist. Sie haben auch den Pfad für Ihre statischen Dateien hinzugefügt, Ihre IP-Adresse als ALLOWED_HOST für Ihre Anwendung festgelegt und das Python-Betriebssystemmodul importiert, um später Ihren administrativen Benutzer einzurichten.

Der letzte Abschnitt, den Sie zu Ihrer Datei hinzufügen müssen, sind die Datenbankverbindungsinformationen, um Ihre Django-Blog-Anwendung mit MySQL zu verbinden. Hierzu suchen Sie das DATABASES-Wörterbuch innerhalb der Datei. Es wird standardmäßig wie folgt aussehen:

…

DATABASES = {
	'default': {
    	'ENGINE': 'django.db.backends.sqlite3',
    	'NAME': BASE_DIR / 'db.sqlite3',
	}
}
...

Ersetzen Sie die Optionen ENGINE und NAME des DATABASES-Wörterbuchs durch die folgenden Zeilen:

...

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

Die Zeile 'ENGINE': 'django.db.backends.mysql' sagt Django, seinen integrierten MySQL-Datenbank-Backend zu verwenden. Die read_default_file-Option verweist auf /etc/mysql/my.cnf, die MySQL-Optionsdatei, die Sie zuvor bearbeitet haben. Dies sagt Django, wo es die relevanten Verbindungsdetails finden kann, um sich mit der MySQL-Datenbank zu verbinden, die Sie im Schritt 1 erstellt haben.

Beachten Sie, dass Django die Einstellungen für die Datenbankverbindung in folgender Reihenfolge liest:

• OPTIONS
• NAME, USER, PASSWORD, HOST, PORT
• MySQL-Optionsdateien

Indem Sie Django auf Ihre MySQL-Optionsdatei innerhalb der OPTIONS-Einstellung wie in diesem Beispiel verweisen, wird sie Vorrang vor jeder NAME-Einstellung haben, die sonst die Optionsdatei überschreiben würde, wenn Sie außerhalb der OPTIONS-Einstellung darauf verweisen würden.

Zu diesem Zeitpunkt können Sie die Datei speichern und schließen.

Überprüfen Sie als nächstes Änderungen an Migrationen, indem Sie Folgendes ausführen:

python manage.py makemigrations

Dann führen Sie migrate aus, um sicherzustellen, dass die Änderungen durchgeführt werden:

python manage.py migrate

Nachdem Ihre Änderungen migriert wurden, können Sie einen administrativen Benutzer erstellen, den Sie für die Django-Administrationsbenutzeroberfläche verwenden können. Tun Sie dies mit dem Befehl createsuperuser:

python manage.py createsuperuser

Sie werden nach einem Benutzernamen, einer E-Mail-Adresse und einem Passwort für Ihren Benutzer gefragt.

Nachdem Sie diese Informationen ausgefüllt haben, können Sie Ihre Firewall-Einstellungen anpassen, um Tests zuzulassen.

Schritt 6 — Anpassen der Firewall-Einstellungen

Vor dem Testen Ihrer Django-Webanwendung müssen Sie sicherstellen, dass Ihre Firewall-Einstellungen angepasst wurden. Beginnen Sie damit, Ihre ufw-Einstellungen zu ändern, um den Zugriff auf den Port 8000 zu ermöglichen:

sudo ufw allow 8000

Überprüfen Sie den Status, um sicherzustellen, dass diese Berechtigungseinstellungen erfolgreich aktualisiert wurden:

sudo ufw status

Output
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
8000                       ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
8000 (v6)                  ALLOW       Anywhere (v6)

Ihre Firewall-Einstellungen sind nun ordnungsgemäß angepasst, um das Testen Ihrer Verbindung im nächsten Schritt zu ermöglichen.

Schritt 7 — Testen der MySQL-Verbindung zur Anwendung

Jetzt können Sie überprüfen, ob die Konfigurationen in Django Ihren MySQL-Server ordnungsgemäß erkennen. Dies können Sie durch das Ausführen des Servers tun. Wenn dies fehlschlägt, bedeutet dies, dass die Verbindung nicht ordnungsgemäß funktioniert. Andernfalls ist die Verbindung gültig.

Navigieren Sie zunächst zum folgenden Verzeichnis:

cd ~/my_blog_app/blog/

Führen Sie dann den folgenden Befehl aus:

python manage.py runserver your-server-ip:8000

Sie erhalten eine Ausgabe, die der folgenden ähnlich ist:

Output
Performing system checks...

System check identified no issues (0 silenced).
July 19, 2022 - 13:26:08
Django version 4.0.6, using settings 'blog.settings'
Starting development server at http://your-server-ip:8000/
Quit the server with CONTROL-C.

Folgen Sie den Anweisungen aus der Ausgabe und öffnen Sie den vorgeschlagenen Link http://Ihr-Server-IP:8000/, um Ihre Webanwendung anzuzeigen und zu überprüfen, ob sie ordnungsgemäß funktioniert.

Wenn Ihre Seite ähnlich wie im obigen Screenshot aussieht, funktioniert Ihre Django-Anwendung wie erwartet.

Wenn Sie mit dem Testen Ihrer App fertig sind, drücken Sie CTRL + C, um den runserver-Befehl zu stoppen. Dies bringt Sie zurück in Ihre Programmierumgebung.

Wenn Sie bereit sind, Ihre Python-Umgebung zu verlassen, können Sie den Befehl deactivate ausführen:

deactivate

Das Deaktivieren Ihrer Programmierumgebung bringt Sie zurück zur Eingabeaufforderung des Terminals.

Fazit

In diesem Tutorial haben Sie das Grundgerüst Ihres Django-Blogs erstellt. Sie haben MySQL installiert, konfiguriert und mit dem Django-Backend verbunden. Außerdem haben Sie wichtige Informationen zur Datei settings.py Ihrer Anwendung hinzugefügt, wie z. B. TIME_ZONE, ALLOWED_HOSTS, import os und Datenbankanmeldeinformationen, um Ihre Django-Anwendung mit MySQL zu verbinden. Sie haben auch Firewall-Einstellungen angepasst, um einen reibungslosen Ablauf der Tests zu gewährleisten.

Jetzt, da diese grundlegenden Einstellungen und Konfigurationen abgeschlossen sind, können Sie damit beginnen, Modelle zu entwickeln und Migrationen in Ihrer Django-Anwendung anzuwenden.