Django-Tutorial: Die Grundlagen des Django-Frameworks verstehen

Django ist ein hochentwickeltes Python-Web-Framework, das für die schnelle Entwicklung und ein klares, pragmatisches Design eingesetzt wird. Es vereinfacht viele Aufgaben der Webentwicklung, sodass Sie sich auf das Schreiben Ihrer Anwendung konzentrieren können, ohne alles neu einrichten zu müssen.

Dies macht es zu einem der beliebtesten und am weitesten verbreiteten Web-Frameworks für die Erstellung dynamischer, datengesteuerter Websites und Anwendungen.

In diesem Tutorial führen wir Sie durch die Kerngrundlagen von Django und vermitteln Ihnen eine solide Basis für die Erstellung Ihrer ersten Webanwendung. Wir behandeln alles von der Einrichtung eines VPS über die Installation von Python bis hin zur Bereitstellung Ihres Django-Projekts.

Am Ende dieses Tutorials sind Sie rundum über voll funktionsfähige Webanwendungen informiert und verfügen über ein solides Verständnis, wie Sie Ihre eigenen Projekte mit Django weiterentwickeln können. Ganz gleich, ob Sie gerade erst mit der Webentwicklung starten oder Ihre Kenntnisse erweitern möchten – dieses Django-Tutorial wird Ihnen helfen, die Grundlagen zu meistern.

Installation des Django-Frameworks

Bevor wir uns mit der Erstellung Ihrer Django-Anwendung befassen, müssen Sie Ihre Entwicklungsumgebung einrichten. Dieser Vorgang umfasst die Einrichtung eines VPS, die Installation von Python, die Erstellung einer virtuellen Umgebung und die Installation von Django.

Voraussetzungen

Bevor Sie mit Django arbeiten, ist es wichtig, über ein grundlegendes Verständnis bestimmter Konzepte zu verfügen. Folgendes sollten Sie bereits kennen:

• Grundkenntnisse in Python: Fundiertes Verständnis der Python-Grundlagen – Datentypen, Kontrollfluss, Funktionen, Klassen, Module.
• Grundlagen von HTML, CSS und JavaScript: Grundkenntnisse in HTML, CSS und JavaScript.
• Verständnis von Datenbanken: Datenbankkonzepte – Tabellen, Datensätze, Primärschlüssel, Fremdschlüssel. SQL-Kenntnisse sind von Vorteil.
• Vertrautheit mit der Befehlszeilenschnittstelle (CLI): Grundkenntnisse der wichtigsten Linux-Befehle.

Wenn Sie diese Voraussetzungen erfüllen, können Sie die erforderlichen Schritte zur Installation von Django verstehen und auszuführen. Sie sind bereit, mit der Entwicklung Ihrer Webanwendungen zu beginnen.

Einen Django-VPS kaufen

Die Wahl der richtigen Hosting-Umgebung ist entscheidend für den reibungslosen Betrieb Ihrer Django-Anwendung. Ein Virtual Private Server (VPS) bietet mehr Kontrolle, Skalierbarkeit und Ressourcen als Shared Hosting und eignet sich daher ideal für Django-Projekte. Hostingers Django VPS-Hosting ist eine ausgezeichnete Wahl und bietet sowohl erschwingliche Pläne als auch Server, die sich einfach einrichten und verwalten lassen.

Berücksichtigen Sie bei der Auswahl eines VPS-Plans von Hostinger die Anforderungen Ihres Projekts:

• CPU und RAM: Eine schnellere CPU und mehr RAM sorgen für eine bessere Leistung, insbesondere bei komplexeren Anwendungen oder höheren Datenverkehrsaufkommen.
• Speicherplatz: Django-Anwendungen arbeiten häufig mit Datenbanken und statischen Dateien. Stellen Sie sicher, dass Ihr VPS über ausreichend SSD-Speicherplatz für Ihre Anforderungen verfügt.
• Bandbreite: Wählen Sie je nach erwartetem Datenverkehr einen Plan mit ausreichender Bandbreite, um Ihren Besucher ein verzögerungsfreies Erlebnis zu bieten.

Für ein einfaches Django-Projekt sollte ein VPS-Plan der unteren Preisklasse wie KVM 1 oder KVM 2 ausreichen; wenn Ihr Projekt jedoch wächst, können Sie problemlos auf Pläne der höheren Preisklasse upgraden und mehr Ressourcen erhalten.

Sobald Sie sich für einen VPS-Plan entschieden und den Kauf abgeschlossen haben, müssen Sie nur noch diesen Schritten folgen, um den Server einzurichten:

1. Starten Sie die VPS-Einrichtung: Melden Sie sich bei hPanel an – auf der Startseite sehen Sie eine ausstehende VPS-Einrichtung, die in etwa so aussieht:

Klicken Sie im nächsten Fenster auf Einrichten und Loslegen.

2. Wählen Sie einen Standort für Ihren VPS aus: Überlegen Sie, aus welcher Region Sie Traffic erwarten können. Die Region mit der geringsten Latenz ist nicht unbedingt die beste für Ihre Anwendung – etwa wenn der erwartete Traffic aus Australien kommt, während Sie sich in Europa befinden.

3. Wählen Sie eine Betriebssystemvorlage aus: Für diese Anleitung sollten Sie Plain OS Ubuntu auswählen; Hostinger bietet jedoch auch ein Betriebssystem mit Panel-Optionen und ein Betriebssystem mit Anwendungsstack (vorinstallierte Software-Abhängigkeiten) an.
4. Richten Sie Ihre VPS-Anmeldedaten ein: Geben Sie das Root-Passwort ein und fügen Sie gegebenenfalls einen SSH-Schlüssel hinzu. Schließen Sie die Einrichtung ab.
5. Stellen Sie eine Verbindung über SSH her: Verwenden Sie einen SSH-Client (z. B. PuTTY für Windows oder das Terminal für macOS/Linux), um eine Verbindung zum Server herzustellen. Geben Sie in Ihrem Terminal Folgendes ein:

ssh root@your_vps_ip

Ersetzen Sie your_vps_ip durch die VPS-IP-Adresse von Hostinger. Sie werden anschließend aufgefordert, Ihr Root-Passwort einzugeben.

6. Aktualisieren Sie den Server: Es ist wichtig, sicherzustellen, dass Ihr Server auf dem neuesten Stand ist. Führen Sie den folgenden Befehl aus, um die Systempakete zu aktualisieren:

apt update && apt upgrade -y

Nachdem der VPS nun bereit ist, können Sie Python und andere Abhängigkeiten für die Django-Entwicklung installieren.

Python installieren

Um Django ausführen zu können, müssen Sie Python und pip auf Ihrem VPS installieren. Bei den meisten modernen Linux-Distributionen, wie beispielsweise Ubuntu, ist Python bereits vorinstalliert.

Falls Python bei Ihnen nicht installiert ist oder aktualisiert werden muss, können Sie dies ganz einfach tun. Verwenden Sie die folgenden Befehle, um die aktuelle Python-Version zu überprüfen und die neueste Version von Python 3 zu installieren:

1. Überprüfen Sie, ob Python installiert ist:

python3 --version

2. Wenn Ihre Befehlszeile die Python-Versionsnummer ausgibt, ist die Programmiersprache bereits installiert. In diesem Fall müssen Sie lediglich pip installieren:

apt install python3-pip

3. Installieren Sie Python und pip (falls erforderlich):

apt install python3 python3-pip -y

Sobald Python installiert ist, können Sie eine virtuelle Umgebung einrichten.

Eine virtuelle Umgebung einrichten

Eine virtuelle Umgebung ist ein isolierter Bereich, in dem Sie Python-Pakete und Abhängigkeiten für ein bestimmtes Projekt installieren können. Diese Vorgehensweise hat keine Auswirkungen auf die systemweite Python-Umgebung oder andere Projekte.

Dies ist bei der Arbeit mit Django von entscheidender Bedeutung, da verschiedene Projekte möglicherweise unterschiedliche Versionen von Paketen erfordern. Eine virtuelle Umgebung stellt sicher, dass die Abhängigkeiten jedes Projekts klar abgegrenzt sind und nicht mit anderen in Konflikt geraten.

Gründe für die Verwendung einer virtuellen Umgebung sind:

• Isolation: Hält die Abhängigkeiten Ihres Projekts von anderen Python-Projekten getrennt.
• Versionsverwaltung: Sie können in jedem virtuellen Arbeitsbereich unterschiedliche Versionen von Paketen installieren und so Konflikte zwischen Projekten vermeiden.
• Übersichtlichere Umgebung: Sie können mit Paketen experimentieren, ohne die globale Python-Umgebung auf Ihrem Server zu beeinträchtigen.

Befolgen Sie diese Schritte, um eine virtuelle Umgebung auf Ihrem VPS einzurichten:

1. Installieren Sie das venv-Paket (falls es noch nicht installiert ist):

apt install python3-venv -y

2. Erstellen Sie das Verzeichnis, in dem Sie Ihr Django-Projekt speichern möchten, wechseln Sie dorthin und erstellen Sie eine virtuelle Umgebung:

mkdir myprojectcd myproject

Ersetzen Sie myproject durch den Namen, den Sie Ihrem Projektordner geben möchten.

3. Erstellen Sie mit venv eine virtuelle Umgebung:

python3 -m venv env_name

4. Aktivieren Sie die virtuelle Umgebung:

source env_name/bin/activate

Nach der Aktivierung ändert sich die Shell-Eingabeaufforderung entsprechend der Umgebung (z. B. (env_name)), was anzeigt, dass Sie in Ihrer virtuellen Umgebung arbeiten.

Diese Konfiguration stellt sicher, dass alle Django-bezogenen Abhängigkeiten innerhalb der virtuellen Umgebung isoliert sind, wodurch Ihr Server übersichtlich und strukturiert bleibt.

Django installieren

Nachdem Sie Ihre virtuelle Umgebung eingerichtet haben, besteht der nächste Schritt darin, das Django-Framework selbst zu installieren. Dies können Sie mithilfe des Python-Paketmanagers pip tun. Durch die Installation von Django in Ihrer virtuellen Umgebung wird sichergestellt, dass es von anderen Projekten isoliert ist und unabhängig verwaltet werden kann.

Befolgen Sie zur Installation von Django die folgenden Schritte:

1. Installieren Sie bei aktivierter virtueller Umgebung mit pip die neueste Version von Django:

pip install django

Dadurch werden alle Abhängigkeiten sowie das Django-Web-Framework in die virtuelle Umgebung heruntergeladen und installiert.

2. Verwenden Sie den folgenden Befehl, um zu überprüfen, ob Django installiert ist, und um die Version zu ermitteln:

django-admin --version

Dadurch wird die aktuell in Ihrer Umgebung installierte Django-Version angezeigt, was zusätzlich bestätigt, dass die Installation erfolgreich war.

Nachdem Ihr VPS für das Django-Hosting vorbereitet ist, können Sie mit der Entwicklung Ihrer Anwendung beginnen.

Ein neues Django-Projekt erstellen

Nun ist es an der Zeit, Ihre erste Django-App zu erstellen. In diesem Abschnitt legen Sie die Grundlage für den Code, die Sie benötigen, um mit der Entwicklung Ihrer Website zu beginnen.

Erstellen Sie folgendermaßen ein neues Django-Projekt:

1. Wechseln Sie in Ihr Projektverzeichnis: Falls Sie sich noch nicht in dem Verzeichnis befinden, in dem Sie das Projekt erstellen möchten, dann verwenden Sie den Befehl cd, um dorthin zu wechseln.
2. Führen Sie den Befehl startproject aus: Verwenden Sie den Django-Befehl startproject, um ein neues Projekt zu erstellen. Ersetzen Sie myproject durch den Namen Ihres Projekts:

django-admin startproject myproject

Dadurch wird ein neues Verzeichnis namens myproject erstellt, das die Standard-Projektstruktur enthält.

3. Navigieren Sie anschließend in den inneren Ordner Ihres Projekts:

cd myproject/myproject

4. Fügen Sie die IP-Adresse Ihres Servers zu ALLOWED_HOSTS hinzu: Verwenden Sie einen der standardmäßigen Ubuntu-Texteditoren (nano oder vim) und öffnen Sie die Datei settings.py:

vim settings.py

Suchen Sie die Einstellung „ALLOWED_HOSTS“ und bearbeiten Sie sie, um die IP-Adresse Ihres VPS wie folgt hinzuzufügen:

ALLOWED_HOSTS = ['your_vps_ip']

Ersetzen Sie „your_vps_ip“ durch die tatsächliche IP-Adresse Ihres VPS aus der Hostinger-Konsole.

5. Starten Sie den Entwicklungsserver: Um zu überprüfen, ob alles korrekt eingerichtet ist, können Sie den Django-Entwicklungsserver starten. Kehren Sie zur übergeordneten Projektkategorie zurück und führen Sie „runserver“ aus:

python manage.py runserver 0.0.0.0:8000

Öffnen Sie nun Ihren Browser und rufen Sie http://your_vps_ip:8000/ auf – ersetzen Sie dabei „your_vps_ip“ durch Ihre tatsächliche VPS-IP-Adresse. Wenn alles korrekt ausgeführt wurde, sollte die Django-Begrüßungsseite angezeigt werden:

Wenn Sie diese Schritte befolgt haben, haben Sie erfolgreich ein Standard-Django-Projekt auf Ihrem VPS erstellt und ausgeführt. Im weiteren Verlauf dieses Django-Tutorials werden wir uns eingehender mit der Entwicklung der Anwendung und dem allgemeinen Verständnis von Django befassen.

Die Struktur eines Django-Projekts verstehen

Durch die Ausführung des Befehls „startproject“ wird eine grundlegende Django-Projektstruktur erstellt, die mehrere wichtige Dateien und Verzeichnisse umfasst. Hier finden Sie eine Übersicht über die Struktur und den Zweck der einzelnen Komponenten:

Jede dieser Dateien und Verzeichnisse spielt eine bestimmte Rolle in Ihrem Django-Projekt:

1. manage.py:

Dies ist ein Befehlszeilenprogramm, das Ihnen die Interaktion mit Ihrem Django-Projekt erleichtert. Sie verwenden es für Aufgaben wie das Starten des Entwicklungsservers, die Migration von Datenbanken und die Verwaltung Ihrer Anwendung. So sieht es aus:

Dies sind seine wichtigsten Funktionen:

Legt die Umgebungsvariable fest, um Django mitzuteilen, welche Konfigurationsdatei verwendet werden soll.

Führt verschiedene Django-Befehle aus, wie z. B. „runserver“, „migrate“ und andere.

2. myproject/:

Das innere Projektverzeichnis, das die zentralen Einstellungen, Konfigurationen und andere Standarddateien für ein Django-Projekt enthält.

3. __init__.py:

Diese Datei kennzeichnet das Verzeichnis als Python-Paket, sodass der Code als Modul in Python importiert werden kann. Sie ist standardmäßig leer.

4. settings.py:

Dies ist eine der wichtigsten Dateien in Django. Sie enthält alle Konfigurationseinstellungen für Ihr Projekt, einschließlich Datenbankkonfigurationen, installierter Apps, Middleware und Einstellungen für statische Dateien.

5. urls.py:

Diese Datei definiert die URL-Routen für Ihre Anwendung. Sie ordnet URLs den Views zu, die Anfragen verarbeiten und Antworten zurückgeben.

Wenn Sie Ihrer Anwendung weitere Funktionen hinzufügen, erweitern Sie die urlpatterns, um die Routen für Ihre eigenen Views einzubinden.

6. asgi.py:

Diese Datei dient als Einstiegspunkt für ASGI-kompatible Webserver, um Ihr Projekt bereitzustellen. ASGI (Asynchronous Server Gateway Interface) ist der Standard für asynchrone Django-Anwendungen.

6. wsgi.py:

Diese Datei ist der Einstiegspunkt für WSGI-kompatible Webserver wie Gunicorn oder uWSGI, um Ihr Projekt in einer Produktionsumgebung bereitzustellen.

Wenn Sie die Rolle der einzelnen Dateien und Verzeichnisse verstehen, sind Sie in der Lage, Einstellungen anzupassen, URLs hinzuzufügen und die Struktur Ihres Projekts zu verwalten.

Django-Modelle und Datenbanken verstehen

Nachdem Ihr Django-Projekt eingerichtet ist und läuft, besteht der nächste Schritt darin, sich mit einer der Kernkomponenten jeder Webanwendung auseinanderzusetzen: der Datenverwaltung. Untersuchen wir, wie Django mit Modellen und Datenbanken umgeht, um dynamische, datengesteuerte Anwendungen zu ermöglichen.

Modelle erstellen und migrieren

In Django definieren Modelle die Struktur Ihrer Datenbanktabellen. Es handelt sich um Python-Klassen, die direkt Datenbanktabellen zugeordnet sind und Ihnen eine bequeme Interaktion mit Ihren Daten ermöglichen. Jede Modellklasse repräsentiert eine Tabelle, und jedes Modellattribut repräsentiert ein Feld in der Tabelle.

Django abstrahiert den SQL-Code, wodurch das Erstellen, Aktualisieren und Verwalten von Datenbanken vereinfacht wird, ohne dass Sie rohe SQL-Abfragen schreiben müssen.

Ein Modell erstellen

Um ein Modell zu erstellen, müssen Sie eine Python-Klasse in der Datei „models.py“ einer Ihrer Apps definieren. Jedes Attribut der Klasse entspricht einem Datenbankfeld, und Django kümmert sich automatisch um die zugrunde liegende Datenbankstruktur.

Hier ist ein Beispiel für ein einfaches Modell in Django:

# In your app's models.py file
from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=100)
    published_date = models.DateField()
    isbn = models.CharField(max_length=13, unique=True)

    def __str__(self):
        return self.title

• title und author: Zeichenfelder (CharField) mit einer maximalen Länge
• published_date: Ein Datumsfeld (DateField)
• isbn: Ein Zeichenfeld mit einer Eindeutigkeitsbeschränkung

Die Methode __str__() stellt sicher, dass bei der Abfrage eines Buches der Titel des Buches als Zeichenfolgenrepräsentation zurückgegeben wird.

Hinzufügen des Modells zur Datenbank

Sobald Sie Ihr Modell erstellt haben, muss Django es in eine Datenbanktabelle umsetzen. Dies geschieht mithilfe von Migrationen – Dateien, mit denen Django Änderungen an Ihren Modellen nachverfolgt.

1. Erstellen Sie eine Migration: Um die Migrationsdatei für Ihr neues Modell zu erstellen, führen Sie folgenden Befehl aus:

python manage.py makemigrations

Django analysiert die Änderungen in Ihrer Datei „models.py“ und generiert eine Migrationsdatei, die diese Änderungen in SQL-ähnlichen Anweisungen beschreibt.

Sie erhalten eine Ausgabe, die in etwa so aussieht:

Migrations for 'myapp':
  myapp/migrations/0001_initial.py
    - Create model Book

2. Wenden Sie die Migration an: Nachdem die Migration generiert wurde, sollten Sie sie mit dem Befehl migrate auf die Datenbank anwenden:

python manage.py migrate

Dadurch werden die erforderlichen Tabellen in Ihrer Datenbank angelegt. Nun wird das Modell „Book“ durch eine entsprechende Tabelle „Book“ in Ihrer Datenbank repräsentiert, und Sie können Daten hinzufügen, abfragen und verwalten.

Einrichten der Datenbank

Django unterstützt mehrere Datenbanken, sodass Sie die für Ihr Projekt am besten geeignete auswählen können. Die Standarddatenbank in Django ist SQLite, die ressourcenschonend und einfach einzurichten ist und sich daher ideal für die Entwicklung und für kleine Projekte eignet.

Für Produktionsumgebungen werden jedoch aufgrund ihrer Skalierbarkeit und Leistungsfähigkeit robustere Datenbanken wie PostgreSQL, MySQL oder MariaDB empfohlen.

Django bietet integrierte Unterstützung für all diese Datenbanken. Beginnen wir mit der Einrichtung der Standard-SQLite-Datenbank.

Einrichtung der Standard-SQLite-Datenbank

Standardmäßig ist Django für die Verwendung von SQLite konfiguriert, das bereits mit Python vorinstalliert ist, sodass keine zusätzliche Einrichtung erforderlich ist. Auf diese Weise stellen Sie sicher, dass Ihr Projekt für die Verwendung von SQLite bereit ist:

1. Öffnen Sie die Datei settings.py Ihres Projekts, die sich im Projektordner befindet (myproject→myproject→settings.py).
2. Gehen Sie zum Abschnitt „DATABASES“ in der Datei „settings.py“, wo Django SQLite bereits als Standarddatenbank konfiguriert hat. So sieht der Eintrag aus:

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

• ENGINE: Gibt das Datenbank-Backend an (in diesem Fall SQLite).
• NAME: Der Pfad zur SQLite-Datenbankdatei (db.sqlite3). Django erstellt diese Datei automatisch, wenn Sie die erste Migration ausführen.

3. Nachdem Sie die Datenbankeinstellungen überprüft haben, müssen Sie die ersten Migrationen durchführen, um die Standardtabellen (wie „users“ und „sessions“) einzurichten. Führen Sie den folgenden Befehl aus:

python manage.py migrate

Dieser Befehl erstellt die Datei „db.sqlite3“ im Stammverzeichnis Ihres Projektverzeichnisses und richtet alle für den Betrieb Ihrer Anwendung erforderlichen Tabellen ein.

4. Sobald die Migrationen abgeschlossen sind, sollten Sie überprüfen, ob die Datei „db.sqlite3“ in Ihrem Projektordner erstellt wurde. Diese Datei speichert Ihre Datenbank lokal und wird mit dem Hinzufügen weiterer Daten immer größer.

Datenbankintegration

Nachdem Sie die Standard-SQLite-Datenbank für die Entwicklung eingerichtet haben, müssen Sie möglicherweise ein leistungsfähigeres Datenbankmanagementsystem (DBMS) integrieren, wenn Ihr Projekt wächst. Django unterstützt mehrere DBMS, darunter PostgreSQL, MySQL, MariaDB und Oracle, die jeweils ihre eigenen Stärken und Integrationsprozesse aufweisen.

Werfen wir einen Blick auf die einzelnen Optionen:

• SQLite: Dies ist die Standarddatenbank in Django und eignet sich ideal für die Entwicklung sowie für kleine Projekte. Sie ist ressourcenschonend, dateibasiert und erfordert keine über die von Django standardmäßig bereitgestellten Funktionen hinausgehende Einrichtung. Für Produktionsumgebungen ist sie jedoch nicht geeignet, da ihr fortgeschrittene Funktionen wie gleichzeitige Schreibvorgänge, Skalierbarkeit und Robustheit bei hohem Datenverkehr fehlen.
  
  Einrichtung: SQLite erfordert keine zusätzliche Einrichtung in Django; es ist sofort einsatzbereit.
  
  Konfiguration: Django ist für die Verwendung von SQLite mit den folgenden Einstellungen in settings.py vorkonfiguriert:

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

Beachten Sie, dass SQLite nur zwei Parameter benötigt – ENGINE und NAME.

• PostgreSQL: Eine leistungsstarke Open-Source-Datenbank mit erweiterten Funktionen wie der Unterstützung komplexer Abfragen, Datentypen wie JSON und Volltextsuche. Aufgrund ihrer Skalierbarkeit und ihres Funktionsumfangs wird sie für Django-Anwendungen in der Produktion dringend empfohlen. PostgreSQL ist dafür bekannt, sich streng an SQL-Standards zu halten und hat sich als zuverlässig für komplexe und groß angelegte Anwendungen erwiesen.
  
  Einrichtung: Für PostgreSQL muss das Paket„psycopg2“ installiert werden, das als Adapter zwischen Django und der PostgreSQL-Datenbank fungiert.
  
  Konfiguration: Neben den Standardparametern „ENGINE“ und „NAME“ für SQLite erfordert PostgreSQL zusätzlich die Angaben „USER“, „PASSWORD“, „HOST“ und „PORT“. Alle diese Parameter werden in der Datei „settings.py“ im Abschnitt „DATABASES“ konfiguriert:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydatabase',
        'USER': 'mydatabaseuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

Unterschiede: Im Gegensatz zu SQLite ist PostgreSQL eine voll ausgestattete Datenbank, die mehrere gleichzeitige Benutzer, erweiterte Abfragen und Transaktionen unterstützt. Sie müssen PostgreSQL auf Ihrem Server installieren, eine Datenbank und einen Benutzer anlegen sowie komplexere Konfigurationen vornehmen.

• MySQL / MariaDB: Beide sind schnelle und zuverlässige relationale Datenbanken, die in der Webentwicklung weit verbreitet sind. MySQL ist für seine Geschwindigkeit bekannt, während MariaDB – ein Fork von MySQL – sich stärker auf die gemeinschaftsgetriebene Entwicklung konzentriert und vollständig mit MySQL kompatibel ist. Diese Datenbanken eignen sich hervorragend für Webanwendungen mit hohem Datenverkehr und werden oft aufgrund ihrer Leistung bevorzugt.
  
  Einrichtung: Sowohl MySQL als auch MariaDB nutzen das mysqlclient-Paket für die Anbindung an Django.
  
  Konfiguration: Beide verwenden dieselben Parameter wie PostgreSQL, die in der Datei settings.py im Abschnitt DATABASES konfiguriert werden:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',  # or 'django.db.backends.mariadb' for MariaDB
        'NAME': 'mydatabase',
        'USER': 'mydatabaseuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',
        'PORT': '3306',
    }
}

Unterschiede: MySQL und MariaDB sind für ihre Leistung bei großen Datensätzen und stark frequentierten Webanwendungen bekannt. Sie unterstützen mehrere Speicher-Engines, ermöglichen schnelle Lesevorgänge und können Millionen von Abfragen zügig verarbeiten.

• Oracle / Microsoft SQL Server: Diese Datenbanken der Enterprise-Klasse bieten erhebliche Leistungsfähigkeit, insbesondere in großen Webanwendungen. Ihre Einrichtung kann jedoch komplexer sein, und sie werden in der Regel nur in bestimmten Unternehmensumgebungen eingesetzt, in denen das Unternehmen Oracle oder SQL Server bereits für andere Software nutzt.
  
  Einrichtung: Beide erfordern zusätzliche Treiber für die Integration mit Django, wie beispielsweise cx_Oracle für Oracle oder pyodbc für SQL Server. Diese Datenbanken werden typischerweise in Unternehmensumgebungen eingesetzt, in denen andere Unternehmenssoftware auf diese Systeme angewiesen ist.
  
  Konfiguration: Jedes dieser Systeme erfordert komplexere Einrichtungsprozesse, darunter die Serverinstallation, die Einrichtung von Treibern und die Konfiguration der Datenbank-Anmeldedaten in der Datei settings.py – ähnlich wie bei den vorherigen Optionen.
  
  Unterschiede: Oracle und SQL Server bieten Funktionen auf Unternehmensniveau wie erweiterte Transaktionsverarbeitung, optimierte Leistung und die Integration in groß angelegte Systeme. Ihre Einrichtung ist komplexer und wird häufig von spezialisierten Datenbankadministratoren übernommen.

Für welche Lösung sollten Sie sich also entscheiden? Lassen Sie es uns einfach und klar formulieren:

• Entwicklung und Tests: Bleiben Sie bei SQLite. Es ist einfach, erfordert keine Einrichtung und eignet sich ideal für lokale Tests.
• Kleine Produktionsumgebungen: Für kleinere Webanwendungen mit geringem Datenverkehr sind MySQL oder MariaDB eine gute Wahl, da diese eine bessere Leistung als SQLite bieten und leichter zu erlernen sind als PostgreSQL.
• Groß angelegte Produktion: PostgreSQL wird am ehesten für Django-Projekte empfohlen, die Skalierbarkeit, Sicherheit und erweiterte Funktionen erfordern.
• Unternehmensumgebungen: Wenn Sie in einem Unternehmensumfeld arbeiten, in dem Oracle oder SQL Server für andere Anwendungen verwendet werden, sind diese Datenbanken aufgrund von Integrationsanforderungen möglicherweise die beste Wahl.

Einrichtung von PostgreSQL mit Django

In diesem Abschnitt gehen wir den Prozess der Integration von PostgreSQL in Django durch, da es sich um eine der am häufigsten verwendeten Datenbanken für Produktionsanwendungen handelt.

1. Installieren Sie PostgreSQL: Um PostgreSQL in Django zu integrieren, müssen Sie zunächst PostgreSQL auf Ihrem System installieren:

sudo apt update

sudo apt install postgresql postgresql-contrib

2. Installieren Sie den PostgreSQL-Adapter für Django: Django nutzt das Paket„psycopg2“ für die Kommunikation mit PostgreSQL. Installieren Sie es mit pip:

pip install psycopg2

3. Wechseln Sie zum PostgreSQL-Benutzer:

sudo -u postgres psql

4. Erstellen Sie eine neue Datenbank:

CREATE DATABASE mydatabase;

5. Erstellen Sie einen Benutzer mit einem Passwort:

CREATE USER mydatabaseuser WITH PASSWORD 'mypassword';

6. Gewähren Sie „mydatabaseuser“ alle Berechtigungen für die Datenbank:

GRANT ALL PRIVILEGES ON DATABASE mydatabase TO mydatabaseuser;

7. Beenden Sie die PostgreSQL-Shell:

\q

8. Konfigurieren Sie Django für die Verwendung von PostgreSQL: Öffnen Sie Ihre Datei „settings.py“ und suchen Sie den Abschnitt „DATABASES“. Passen Sie ihn wie folgt für PostgreSQL an:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydatabase',
        'USER': 'mydatabaseuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',  # Use '127.0.0.1' if 'localhost' doesn't work
        'PORT': '5432',       # Default PostgreSQL port
    }
}

Die tatsächlichen Werte für PASSWORD und USER sollten mit denen übereinstimmen, die Sie in Schritt 5 festgelegt haben.

9. Wenden Sie die Migrationen an: Nachdem Ihre Datenbank nun konfiguriert ist, müssen Sie die Migrationen Ihres Projekts anwenden, um die erforderlichen Tabellen in PostgreSQL einzurichten:

python manage.py migrate

Dieser Befehl erstellt die erforderlichen Tabellen in Ihrer PostgreSQL-Datenbank.

10. Testen Sie die Verbindung: Starten Sie abschließend den Django-Entwicklungsserver mit dem Befehl„runserver“, um zu überprüfen, ob die PostgreSQL-Integration erfolgreich war:

python manage.py runserver

Öffnen Sie http://127.0.0.1:8000/ in Ihrem Browser. Wenn die Django-Begrüßungsseite ohne Fehler angezeigt wird, funktioniert Ihre Datenbankverbindung einwandfrei.

Da Ihre PostgreSQL-Datenbank nun vollständig integriert ist, ist Django bereit, größere und komplexere Datensätze zu verarbeiten, wodurch Ihr Projekt skalierbar und produktionsreif wird.

Erstellen von Ansichten und Vorlagen

Nachdem die Datenbank und die Modelle für die Verwaltung der Daten Ihrer Anwendung eingerichtet sind, besteht der nächste Schritt darin, diese Informationen den Benutzern anzuzeigen und interaktive Oberflächen zu erstellen.

Hier kommen Ansichten und Vorlagen ins Spiel, mit denen Sie die Logik und Struktur hinter den Webseiten definieren können, mit denen die Benutzer interagieren werden.

Views verstehen

Django-Ansichten sind eine wesentliche Komponente, die die Logik hinter dem definiert, was ein Benutzer sieht, wenn er mit Ihrer Anwendung interagiert.

Einfach ausgedrückt: Eine Ansicht nimmt eine Webanfrage entgegen, verarbeitet sie und gibt eine Antwort zurück – in der Regel in Form einer gerenderten HTML-Seite. Ansichten bilden mithilfe von Modellen und Vorlagen eine Brücke zwischen Ihrer Datenbank und der Benutzeroberfläche.

In Django gibt es zwei Haupttypen von Views: funktionsbasierte Views (FBVs) und klassenbasierte Views (CBVs). Beide dienen demselben Zweck, bieten jedoch unterschiedliche Möglichkeiten zur Organisation des Codes.

Funktionsbasierte Views (FBVs)

Funktionsbasierte Views sind einfache Python-Funktionen, die ein Anfrageobjekt entgegennehmen und eine Antwort zurückgeben. Sie werden häufig für einfachere Anwendungsfälle verwendet oder wenn Sie mehr Kontrolle über den Ablauf der Logik benötigen.

Hier ist ein Beispiel für eine einfache FBV, die eine HTML-Vorlage rendert:

from django.shortcuts import render

# Function-based view
def homepage(request):
    return render(request, 'homepage.html')

In diesem Beispiel:

• request: Das vom Browser des Benutzers gesendete HTTP-Anfrageobjekt.
• render: Kombiniert die Vorlage „homepage.html“ mit den bereitgestellten Kontextdaten und gibt eine HTTP-Antwort zurück.

FBVs sind leicht zu verstehen und zu implementieren, doch wenn Views komplexer werden – beispielsweise durch Formulare oder Authentifizierung –, kann ihre Wartung aufwendiger werden.

Klassenbasierte Ansichten (CBVs)

Klassenbasierte Views hingegen ermöglichen es Ihnen, Views mithilfe objektorientierter Programmierprinzipien effizienter zu strukturieren. CBVs sind flexibler und wiederverwendbarer, da sie auf Python-Klassen basieren.

Django bietet integrierte generische Views wie „ListView“ und „DetailView“, die gängige Anwendungsfälle abdecken. Diese Views ermöglichen es Ihnen, sich stärker auf deren Anpassung zu konzentrieren, anstatt sich wiederholende Logik neu zu schreiben.

Hier ist ein Beispiel für eine CBV, die dieselbe Funktion wie die vorherige FBV erfüllt:

from django.views.generic import TemplateView

# Class-based view
class HomePageView(TemplateView):
    template_name = 'homepage.html'

In diesem Beispiel:

• TemplateView: Eine integrierte generische Ansicht, die eine Vorlage rendert.
• template_name: Gibt die darzustellende Vorlagendatei an, genau wie im FBV-Beispiel.

Um dieses CBV in der URL-Konfiguration zu verwenden, müssen Sie die Methode .as_view() einbinden, wenn Sie es in die Datei „urls.py“ einfügen:

from django.urls import path
from .views import HomePageView

urlpatterns = [
    path('', HomePageView.as_view(), name='home'),
]

Wann sollten FBVs gegenüber CBVs verwendet werden?

• Verwenden Sie FBVs, wenn Sie Einfachheit und vollständige Kontrolle über Ihre View-Logik benötigen. Sie sind oft intuitiver für kleine Views oder benutzerdefinierte Logik, die nicht in die vordefinierten View-Muster von Django passt.
• Verwenden Sie CBVs, wenn Sie den DRY-Prinzipien (Don’t Repeat Yourself) folgen und vorhandene Logik wiederverwenden möchten. CBVs sind ideal, wenn Ihre Ansichten an Komplexität zunehmen, beispielsweise bei der Verarbeitung von Formularen, paginierten Daten oder Standard-CRUD-Operationen.

Sowohl FBVs als auch CBVs sind fester Bestandteil von Django, und die Wahl zwischen beiden hängt von den Anforderungen Ihres Projekts und Ihren persönlichen Vorlieben ab.

Arbeiten mit Vorlagen

Das Template-System in Django ist darauf ausgelegt, die Darstellung von Daten von der zugrunde liegenden Logik zu trennen. Templates sind im Wesentlichen HTML-Dateien, die dynamische Inhalte enthalten und es Ihnen ermöglichen, von Ihren Views übergebene Daten anzuzeigen. Die Django Template Language (DTL) stellt Platzhalter und Logik wie Schleifen und Bedingungen bereit, um dynamische Daten in HTML einzufügen.

Vorlagen spielen eine entscheidende Rolle bei der Gestaltung des Erscheinungsbilds Ihrer Webseiten und sorgen gleichzeitig für eine klare Trennung der Zuständigkeiten zwischen der Logik, die von den Views übernommen wird, und der Benutzeroberfläche.

Erstellen einer Vorlage

Um eine Vorlage in Django zu erstellen, müssen Sie eine HTML-Datei in einem Verzeichnisnamens „templates“ anlegen. Die Verzeichnisstruktur könnte wie folgt aussehen:

myproject/
│
├── myapp/
│   ├── templates/
│   │   └── myapp/
│   │       └── homepage.html
│   └── views.py
│
└── manage.py

In dieser Struktur sucht Django automatisch nach Vorlagen im Verzeichnis „templates“ Ihrer App. Sie können die Vorlagen zusätzlich in app-spezifischen Ordnern organisieren (z. B. myapp/homepage.html), um sicherzustellen, dass jede App über eigene Vorlagen verfügt.

Hier ist ein Beispiel für eine einfache Vorlage (homepage.html):

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Home</title>
</head>
<body>
    <h1>Welcome to {{ site_name }}</h1>
    <p>{{ message }}</p>
</body>
</html>

In dieser Vorlage sind {{ site_name }} und {{ message }} Platzhalter, die mit dynamischen Daten aus der Ansicht gefüllt werden.

Rendern einer Vorlage in einer Ansicht

Um eine Vorlage darzustellen, müssen Sie diese mithilfe der Django-Funktion render() an die Ansicht übergeben. Hier ist ein Beispiel dafür, wie die Vorlage „homepage.html“ mit einigen Kontextdaten in einer funktionsbasierten Ansicht (FBV) dargestellt wird:

from django.shortcuts import render

def homepage(request):
    context = {
        'site_name': 'My Django Website',
        'message': 'This is the homepage content!'
    }
    return render(request, 'myapp/homepage.html', context)

In diesem Beispiel:

• render(): Kombiniert die Vorlage (homepage.html) mit den Kontextdaten.
• context: Ein Wörterbuch, das die Daten (site_name und message) enthält, die in die Vorlage eingefügt werden sollen.

Wenn ein Benutzer diese Seite aufruft, werden die Platzhalter {{ site_name }} und {{ message }} in der Vorlage durch „Meine Django-Website“ bzw. „Dies ist der Inhalt der Startseite!“ ersetzt.

Vorlagen-Tags und Filter

Django-Vorlagen unterstützen zudem Vorlagen-Tags und Filter, mit denen Sie dynamische Inhalte und Logik in Ihre HTML-Dateien einfügen können.

• Vorlagen-Tags: Führen Sie Logik innerhalb von Vorlagen aus, wie beispielsweise Schleifen und Bedingungen. Beispielsweise eine if-Bedingung:

{% if user.is_authenticated %}
    <p>Welcome back, {{ user.username }}!</p>
{% else %}
    <p>Hello, Guest!</p>
{% endif %}

• Vorlagenfilter: Passen Sie Variablen für die Anzeige an. Beispielsweise können Sie Datumsangaben mit einem Filter formatieren:

<p>Published on {{ article.published_date|date:"F j, Y" }}</p>

Erweiterung von Vorlagen

Django unterstützt die Vererbung von Vorlagen, sodass Sie Basisvorlagen erstellen können, die von anderen Vorlagen erweitert werden können. Dies ist besonders nützlich, um ein einheitliches Layout über mehrere Seiten hinweg beizubehalten, wie beispielsweise eine gemeinsame Kopf- und Fußzeile.

1. Erstellen Sie eine Basisvorlage (base.html):

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{% block title %}My Site{% endblock %}</title>
</head>
<body>
    <header>
        <h1>Site Header</h1>
    </header>

    <main>
        {% block content %}
        <!-- Page-specific content goes here -->
        {% endblock %}
    </main>

    <footer>
        <p>Footer Content</p>
    </footer>
</body>
</html>

2. Erweitern Sie die Basisvorlage in einer untergeordneten Vorlage (homepage.html):

{% extends 'base.html' %}

{% block title %}Home Page{% endblock %}

{% block content %}
    <h2>Welcome to the homepage!</h2>
    <p>This is the homepage content.</p>
{% endblock %}

Durch die Erweiterung der Basisvorlage können Sie die Kopf- und Fußzeile auf verschiedenen Seiten wiederverwenden, wodurch ein einheitliches Layout gewährleistet wird und Wiederholungen vermieden werden.

Verwendung statischer Dateien in Vorlagen

Vorlagen ermöglichen es Ihnen außerdem, mithilfe des Vorlagen-Tags {% static %} auf statische Dateien (wie CSS, JavaScript oder Bilder) zu verweisen. Nutzen Sie Folgendes, um beispielsweise eine CSS-Datei einzubinden:

<link rel="stylesheet" type="text/css" href="{% static 'css/style.css' %}">

Stellen Sie sicher, dass Sie Ihre Verzeichnisse für statische Dateien in settings.py korrekt eingerichtet haben:

STATIC_URL = '/static/'

Durch den effektiven Einsatz des Django-Vorlagensystems können Sie dynamische, datengesteuerte Webseiten erstellen und eine klare Trennung zwischen Logik und Darstellung gewährleisten.

Arbeiten mit URL-Mustern

Der URL-Dispatcher von Django nutzt reguläre Ausdrücke oder Pfadkonverter, um eingehende URL-Anfragen bestimmten Views zuzuordnen. Diese URL-Muster werden in der Datei urls.py definiert, und Django verwendet diese Konfiguration, um zu bestimmen, welcher View eine bestimmte Anfrage bearbeiten soll.

Jedes Django-Projekt verfügt in der Regel über zwei Ebenen der URL-Konfiguration:

1. URLs auf Projektebene: Diese werden in der Stammdatei „urls.py“ (im Hauptverzeichnis des Projekts) definiert; diese Datei enthält die Gesamtstruktur des URL-Routings des Projekts.
2. URLs auf App-Ebene: Jede App innerhalb Ihres Projekts kann über eine eigene „urls.py“-Datei verfügen, was eine modulare URL-Verwaltung ermöglicht. Diese URLs auf App-Ebene werden dann mit den URLs auf Projektebene verknüpft.

Grundlegende URL-Konfiguration

Sehen wir uns an, wie in einem einfachen Projekt URL-Muster eingerichtet werden könnten:

1. URLs auf Projektebene (myproject→urls.py)

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),  # Admin site
    path('', include('myapp.urls')),  # Include app-level URLs for "myapp"
]

• path(): Djangos Funktion zur Definition von URL-Mustern.
• admin.site.urls: Verarbeitet alle adminbezogenen Anfragen.
• include(): Wird verwendet, um URLs auf App-Ebene (aus myapp.urls) in die Hauptprojektkonfiguration einzubinden.

2. URLs auf App-Ebene (myproject→myapp→urls.py)

from django.urls import path
from . import views

urlpatterns = [
    path('', views.homepage, name='home'),  # Maps the root URL to the homepage view
    path('about/', views.about, name='about'),  # Maps "/about/" to the about view
]

• Die Stamm-URL (dargestellt durch „ “) wird der Ansicht „homepage“ zugeordnet.
• Die URL „/about/“ wird der Ansicht „about“ zugeordnet.

URL-Routing mit funktionsbasierten Ansichten (FBVs)

So könnten die entsprechenden Ansichten in der Datei „views.py“ für die oben genannte URL-Konfiguration aussehen:

from django.shortcuts import render

def homepage(request):
    return render(request, 'homepage.html')

def about(request):
    return render(request, 'about.html')

Diese Konfiguration verknüpft die URLs für die Startseite und die „Über uns“-Seite mit den entsprechenden Views und stellt so sicher, dass beim Aufruf von http://example.com/ oder http://example.com/about/ die richtige Vorlage gerendert wird.

URL-Routing mit klassenbasierten Ansichten (CBVs)

Sie können URLs auch klassenbasierten Ansichten (CBVs) zuordnen, die etwas anders behandelt werden. Hier ist ein Beispiel für eine CBV-URL-Zuordnung:

from django.urls import path
from .views import HomePageView, AboutPageView

urlpatterns = [
    path('', HomePageView.as_view(), name='home'),
    path('about/', AboutPageView.as_view(), name='about'),
]

Und die entsprechenden klassenbasierten Ansichten in views.py:

from django.views.generic import TemplateView

class HomePageView(TemplateView):
    template_name = 'homepage.html'

class AboutPageView(TemplateView):
    template_name = 'about.html'

In diesem Fall wird die Methode .as_view() verwendet, um die klassenbasierten Ansichten mit den URL-Mustern zu verknüpfen.

URL-Parameter und dynamisches Routing

Django ermöglicht es Ihnen außerdem, URL-Parameter zu erfassen und an Views weiterzugeben, was für die dynamische URL-Zuordnung beispielsweise bei Blogbeiträgen oder Produktseiten nützlich ist.

Hier ist ein Beispiel, bei dem die URL einen ganzzahligen Parameter erfasst:

from django.urls import path
from . import views

urlpatterns = [
    path('article/<int:id>/', views.article_detail, name='article_detail'),
]

In diesem Fall erfasst <int:id> eine Ganzzahl aus der URL und übergibt sie als Argument an die Ansicht „article_detail“:

def article_detail(request, id):
    # Fetch the article using the provided ID
    article = get_object_or_404(Article, pk=id)
    return render(request, 'article_detail.html', {'article': article})

Wenn ein Benutzer die Seite http://example.com/article/5/ aufruft, übergibt Django den Wert 5 als Argument „id“ an die Ansicht „article_detail“, sodass Sie den entsprechenden Artikel abrufen und anzeigen können

Benannte URL-Muster

Es empfiehlt sich, Ihren URL-Mustern Namen zuzuweisen. Auf diese Weise können Sie in Ihren Vorlagen und Ansichten per Namen auf URLs verweisen, anstatt diese fest einprogrammieren zu müssen.

Im obigen Beispiel in „urls.py“ verfügt jede URL über ein „name“-Argument:

path('about/', views.about, name='about')

In Ihren Vorlagen können Sie dann das Template-Tag {% url %} verwenden, um auf diese benannten URLs zu verweisen:

<a href="{% url 'about' %}">About Us</a>

Auf diese Weise müssen Sie, sollte sich die „about“-URL jemals ändern, diese nur in der URL-Konfiguration aktualisieren und nicht in jeder einzelnen Vorlage.

Durch die Konfiguration und Nutzung der URL-Muster von Django können Sie verschiedene URLs effizient ihren jeweiligen Views zuordnen. Diese Flexibilität ermöglicht es Ihnen, sowohl einfache statische Seiten als auch komplexere, dynamische Inhalte zu verarbeiten, die auf Benutzereingaben zugeschnitten sind.

Verwaltung statischer Dateien in Django

Wir haben Views, Vorlagen und URL-Muster eingerichtet. Um nun eine voll funktionsfähige Django-Anwendung zu erstellen, müssen wir uns mit der Verwaltung statischer Dateien wie CSS, JavaScript und Bildern befassen.

Glücklicherweise bietet Django eine einfache und effiziente Möglichkeit, statische Dateien zu verwalten, und stellt sicher, dass diese während der Entwicklung und Bereitstellung ordnungsgemäß bereitgestellt und organisiert werden.

Einrichten statischer Dateien in Django

Um statische Dateien in Django zu verwalten, müssen Sie Ihr Projekt so konfigurieren, dass es weiß, wo es diese suchen und bereitstellen soll.

Definieren Sie die statische URL und das Verzeichnis in settings.py:

# settings.py
STATIC_URL = '/static/'
STATICFILES_DIRS = [
    BASE_DIR / "static",  # Optional: Add this if you want to store static files in a 'static' folder within your project
]

• STATIC_URL: Legt das URL-Präfix fest, das Django beim Bereitstellen statischer Dateien verwendet.
• STATICFILES_DIRS: Gibt zusätzliche Verzeichnisse an, in denen Django während der Entwicklung nach statischen Dateien sucht.

Standardmäßig sucht Django auch im Verzeichnis „static“ jeder App nach statischen Dateien. Wenn Sie beispielsweise eine App namens „myapp“ haben, können Sie eine Ordnerstruktur wie folgt erstellen:

myapp/
│
├── static/
│   └── myapp/
│       └── style.css
└── views.py

Django erkennt diese Dateien während der Entwicklung automatisch und stellt sie bereit.

Verwendung statischer Dateien in Vorlagen

Um statische Dateien in Ihren Vorlagen zu verwenden, müssen Sie zunächst das Django-Vorlagen-Tag {% static %} einbinden. Anschließend können Sie Ihre statischen Dateien über ihre relativen Pfade referenzieren:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Home Page</title>
    {% load static %}
    <link rel="stylesheet" href="{% static 'myapp/style.css' %}">
</head>
<body>
    <h1>Welcome to My Django App</h1>
    <img src="{% static 'myapp/images/logo.png' %}" alt="Logo">
</body>
</html>

In diesem Beispiel:

• {% load static %}: Lädt das Template-Tag für statische Dateien.
• {% static ‘myapp/style.css’ %}: Löst den Pfad zur Datei „style.css“ im Verzeichnis „static/myapp“ auf.
• {% static ‚myapp/images/logo.png‘ %}: Löst den Pfad zu einer Bilddatei auf.

Sammeln statischer Dateien für die Bereitstellung

Während der Entwicklung stellt Django statische Dateien automatisch bereit, wenn DEBUG = True ist. In der Produktionsumgebung stellt Django statische Dateien jedoch nicht direkt bereit. Stattdessen müssen Sie alle statischen Dateien aus verschiedenen Verzeichnissen sammeln und in einem einzigen Verzeichnis speichern.

Hierfür stellt Django den Management-Befehl collectstatic zur Verfügung:

1. Stellen Sie sicher, dass „django.contrib.staticfiles“ in der Einstellung „INSTALLED_APPS“ enthalten ist:

INSTALLED_APPS = [
    # Other installed apps
    'django.contrib.staticfiles',
]

2. Konfigurieren Sie das Verzeichnis für statische Dateien in settings.py:

STATIC_ROOT = BASE_DIR / 'staticfiles'

STATIC_ROOT: Legt das Verzeichnis fest, in dem Django statische Dateien für die Bereitstellung sammelt.

3. Führen Sie den Befehl collectstatic aus:

python manage.py collectstatic

Dieser Befehl sammelt alle statischen Dateien aus dem Verzeichnis „static“ jeder App sowie aus allen weiteren in STATICFILES_DIRS angegebenen Speicherorten und speichert sie anschließend im Verzeichnis STATIC_ROOT.

Bereitstellung statischer Dateien in der Produktionsumgebung

In einer Produktionsumgebung verwenden Sie in der Regel einen Webserver (wie Nginx oder Apache), um statische Dateien bereitzustellen. Django empfiehlt, Ihren Webserver so zu konfigurieren, dass statische Inhalte effizient bereitgestellt werden, um die Auslastung Ihrer Django-Anwendung zu verringern.

So könnten Sie die Bereitstellung statischer Dateien in einer Nginx-Konfiguration einrichten:

1. Nginx-Konfiguration für statische Dateien:

server {
    listen 80;
    server_name yourdomain.com;

    location /static/ {
        alias /path/to/your/project/staticfiles/;  # The path to STATIC_ROOT
    }

    location / {
        proxy_pass http://127.0.0.1:8000;  # Pass requests to Django app
    }
}

In dieser Konfiguration stellt Nginx statische Dateien direkt aus dem Verzeichnis /static/ bereit, während alle anderen Anfragen an die Django-Anwendung weitergeleitet werden.

Durch die ordnungsgemäße Verwaltung statischer Dateien in Django stellen Sie sicher, dass Ihre Anwendung nicht nur mit Stilen und Bildern ansprechend aussieht, sondern auch nach der Bereitstellung effizient läuft.

Implementierung der Benutzerauthentifizierung und -autorisierung

Da wir immer dynamischere und komplexere Webanwendungen entwickeln, wird die Notwendigkeit, Benutzer zu verwalten, Inhalte zu sichern und den Zugriff zu kontrollieren, immer wichtiger.

Django bietet ein integriertes Authentifizierungssystem, das die Abwicklung von Benutzeranmeldung, -abmeldung, -registrierung und -berechtigungen vereinfacht. Dies ermöglicht es einem Django-Entwickler, sowohl die Benutzerauthentifizierung als auch die Autorisierung effizient zu verwalten.

Benutzerauthentifizierung

Das integrierte Authentifizierungssystem von Django vereinfacht die Benutzerverwaltung durch Funktionen wie Anmeldung, Abmeldung, Passwortverwaltung und Registrierung. Standardmäßig bietet Django Funktionen für das Benutzermodell sowie Authentifizierungsansichten, die die meisten dieser Aufgaben sofort übernehmen.

Einrichten der Benutzeranmeldung und -abmeldung

Um die Anmelde- und Abmeldefunktionalität zu implementieren, können Sie die integrierten Ansichten von Django nutzen, die sich in django.contrib.auth.views befinden. Diese Ansichten übernehmen den Authentifizierungsprozess und vereinfachen den für diese Vorgänge erforderlichen Code.

1. Richten Sie in Ihrer Datei urls.py URLs für die Anmeldung und Abmeldung ein:

from django.urls import path
from django.contrib.auth import views as auth_views

urlpatterns = [
    path('login/', auth_views.LoginView.as_view(), name='login'),
    path('logout/', auth_views.LogoutView.as_view(), name='logout'),
]

• LoginView: Verarbeitet die Benutzeranmeldung.
• LogoutView: Meldet den Benutzer ab und leitet ihn auf die angegebene Seite weiter.

2. Erstellen Sie eine Vorlage für das Anmeldeformular: Sie können eine einfache Anmeldevorlage (login.html) im Verzeichnis „templates“ Ihrer App erstellen:

<form method="post">
    {% csrf_token %}
    <div>
        <label for="username">Username:</label>
        <input type="text" id="username" name="username" required>
    </div>
    <div>
        <label for="password">Password:</label>
        <input type="password" id="password" name="password" required>
    </div>
    <button type="submit">Login</button>
</form>

Diese Vorlage übernimmt die Benutzerauthentifizierung, wenn ein gültiger Benutzername und ein gültiges Passwort übermittelt werden.

3. Erstellen Sie eine Abmeldung: Sie benötigen keine separate Vorlage für die Abmeldung, da dies von Djangos LogoutView übernommen wird. Sie können einfach einen Abmeldelink in Ihre Vorlage einfügen:

<a href="{% url 'logout' %}">Logout</a>

Erstellen einer Ansicht für die Benutzerregistrierung

Django bietet standardmäßig keine integrierte Registrierungsansicht, aber Sie können mithilfe von Djangos UserCreationForm eine solche erstellen:

1. Erstellen Sie eine Registrierungsansicht in views.py:

from django.shortcuts import render, redirect
from django.contrib.auth.forms import UserCreationForm
from django.contrib.auth import login

def register(request):
    if request.method == 'POST':
        form = UserCreationForm(request.POST)
        if form.is_valid():
            user = form.save()
            login(request, user)  # Automatically log the user in after registration
            return redirect('home')  # Redirect to home page after successful registration
    else:
        form = UserCreationForm()
    return render(request, 'register.html', {'form': form})

2. Richten Sie die URL für die Registrierung in urls.py ein:

urlpatterns = [
    path('register/', views.register, name='register'),
]

3. Erstellen Sie die Vorlage für das Registrierungsformular (register.html):

<form method="post">
    {% csrf_token %}
    {{ form.as_p }}
    <button type="submit">Register</button>
</form>

Diese Registrierungsansicht ermöglicht es Benutzern, mithilfe eines einfachen Formulars ein Konto zu erstellen. Nach erfolgreicher Registrierung werden die Benutzer automatisch angemeldet.

Benutzerautorisierung

Die Benutzerautorisierung ermöglicht es, den Zugriff auf bestimmte Ansichten und Aktionen basierend auf den Berechtigungen oder Rollen des Benutzers zu steuern. Das Berechtigungssystem von Django erleichtert die Verwaltung, welche Benutzer auf bestimmte Teile Ihrer Anwendung zugreifen dürfen.

Zugriffseinschränkung durch Anmeldepflicht

Um den Zugriff auf bestimmte Ansichten einzuschränken, können Sie den Django-Dekorator @login_required verwenden, der sicherstellt, dass nur authentifizierte Benutzer auf eine Ansicht zugreifen können:

1. Verwendung von @login_required in Ansichten:

from django.contrib.auth.decorators import login_required

@login_required
def dashboard(request):
    return render(request, 'dashboard.html')

Dadurch wird sichergestellt, dass ein Benutzer, der nicht angemeldet ist, auf die Anmeldeseite weitergeleitet wird.

2. Wenden Sie @login_required in URLs an: Alternativ können Sie @login_required direkt in Ihrer urls.py anwenden, indem Sie Djangos LoginRequiredMixin für klassenbasierte Ansichten verwenden:

from django.contrib.auth.mixins import LoginRequiredMixin
from django.views.generic import TemplateView

class DashboardView(LoginRequiredMixin, TemplateView):
    template_name = 'dashboard.html'

Verwaltung von Benutzerberechtigungen

Mit Django können Sie Benutzern und Gruppen unterschiedliche Berechtigungen zuweisen, mit denen sich der Zugriff auf bestimmte Ansichten oder Aktionen steuern lässt. Berechtigungen können zu Benutzermodellen hinzugefügt und in Ihren Ansichten überprüft werden.

1. Berechtigungen zuweisen: Beim Anlegen von Benutzern oder Gruppen können Sie Berechtigungen zuweisen. So kann beispielsweise ein Administrator die Berechtigung zum Hinzufügen oder Löschen von Inhalten haben, während normale Benutzer Inhalte lediglich anzeigen dürfen.
2. Überprüfung von Berechtigungen in Ansichten: Mit dem Dekorator @permission_required können Sie prüfen, ob ein Benutzer über die erforderlichen Berechtigungen verfügt, bevor Sie ihm den Zugriff auf bestimmte Ansichten gewähren:

from django.contrib.auth.decorators import permission_required

@permission_required('app.add_article')
def add_article(request):
    # View code for adding an article

Nur Benutzer mit der Berechtigung „add_article“ können auf diese Ansicht zugreifen.

Zugriffsbeschränkung anhand von Benutzerrollen

Mit der Gruppenfunktion von Django können Sie Rollen (wie z. B. „Redakteur“ oder „Leser“) erstellen und Benutzer diesen Gruppen zuweisen. Anschließend können Sie die Gruppenzugehörigkeit eines Benutzers überprüfen, um den Zugriff zu steuern.

1. Zuweisung von Benutzern zu Gruppen: Gruppen können im Django-Admin-Panel oder programmgesteuert angelegt werden:

from django.contrib.auth.models import Group, User

group = Group.objects.get(name='editors')
user = User.objects.get(username='john')
user.groups.add(group)  # Assign the user to the 'editors' group

2. Überprüfen der Gruppenmitgliedschaft in Ansichten: Sie können Ansichten basierend auf der Gruppenmitgliedschaft einschränken:

from django.contrib.auth.decorators import user_passes_test

def is_editor(user):
    return user.groups.filter(name='editors').exists()

@user_passes_test(is_editor)
def editor_dashboard(request):
    return render(request, 'editor_dashboard.html')

In diesem Beispiel können nur Benutzer, die der Gruppe „editors“ angehören, auf die Ansicht „editor_dashboard“ zugreifen.

Durch die Nutzung der in Django integrierten Authentifizierungs- und Autorisierungssysteme können Sie die Anmeldung, Registrierung und Berechtigungen von Benutzern sicher verwalten und so sicherstellen, dass sensible Inhalte geschützt sind und der Zugriff ordnungsgemäß kontrolliert wird.

Umgang mit Formularen in Django

Nach der Implementierung der Benutzerauthentifizierung und -autorisierung ist die Verarbeitung von Benutzereingaben über Formulare die nächste entscheidende Funktion jeder Webseite. Django bietet ein leistungsstarkes und flexibles System zum Erstellen, Verarbeiten und Validieren von Formularen.

Das Formularverarbeitungssystem von Django basiert auf Python-Klassen, die Formulare als Objekte darstellen. Diese Formulare lassen sich in Vorlagen ausgeben, validieren und mit nur wenigen Zeilen Code verarbeiten. Formulare können entweder manuell mithilfe der Form-Klasse von Django erstellt oder automatisch aus Modellen mithilfe von ModelForm generiert werden.

Erstellen von Formularen mithilfe der Form-Klasse von Django

Um ein Formular in Django zu erstellen, definieren Sie zunächst eine Formularklasse in Ihrer Datei „forms.py“. Diese Klasse definiert die Felder und die Validierungsregeln.

1. Ein Formular definieren: Hier ist ein Beispiel für ein einfaches Kontaktformular:

# forms.py
from django import forms

class ContactForm(forms.Form):
    name = forms.CharField(max_length=100, label='Your Name')
    email = forms.EmailField(label='Your Email')
    message = forms.CharField(widget=forms.Textarea, label='Your Message')

Dieses Formular enthält drei Felder: Name, E-Mail und Nachricht. Jedes Feld wird durch eine Formularfeldklasse repräsentiert, beispielsweise CharField für kurzen Text, EmailField für E-Mail-Adressen und Textarea für längere Texteingaben.

2. Darstellung des Formulars in einer Vorlage: Um das Formular auf einer Webseite anzuzeigen, müssen Sie es in einer Vorlage darstellen. Sie können das Formular manuell darstellen oder die in Django integrierten Hilfsfunktionen zur Formulardarstellung verwenden:

<form method="post">
    {% csrf_token %}
    {{ form.as_p }}
    <button type="submit">Send Message</button>
</form>

• {% csrf_token %}: Fügt ein CSRF-Token hinzu, um vor Cross-Site-Request-Forgery-Angriffen zu schützen.
• {{ form.as_p }}: Rendert die Formularfelder, wobei jedes Feld zur einfachen Formatierung in ein <p>-Tag eingeschlossen ist.

3. Verarbeitung von Formularübermittlungen: In der Ansicht, die die Formularübermittlung verarbeitet, müssen Sie die Formulardaten validieren und diese verarbeiten, sofern das Formular gültig ist:

# views.py
from django.shortcuts import render
from .forms import ContactForm

def contact_view(request):
    if request.method == 'POST':
        form = ContactForm(request.POST)
        if form.is_valid():
            # Process the data, e.g., send an email or save it to the database
            name = form.cleaned_data['name']
            email = form.cleaned_data['email']
            message = form.cleaned_data['message']
            # Redirect to a success page or show a success message
            return render(request, 'thanks.html')
    else:
        form = ContactForm()
    return render(request, 'contact.html', {'form': form})

In dieser Ansicht:

• Wenn das Formular über eine POST-Anfrage übermittelt wird, werden die Formulardaten validiert.
• form.is_valid(): Prüft, ob die Formulardaten die Validierung bestehen.
• form.cleaned_data: Enthält die validierten Formulardaten, die nun verarbeitet werden können (z. B. zum Versenden einer E-Mail).
• Wenn es sich bei der Anfrage nicht um einen POST-Request handelt, wird dem Benutzer ein leeres Formular zum Ausfüllen angezeigt.

Formularvalidierung und Fehlerbehandlung

Die Formulare von Django verfügen über eine integrierte Validierung, die sicherstellt, dass die übermittelten Daten korrekt und sicher sind. Felder wie EmailField überprüfen automatisch, ob die Eingabe eine gültige E-Mail-Adresse ist. Sie können auch eine benutzerdefinierte Validierungslogik erstellen, um bestimmte Regeln durchzusetzen.

Integrierte Validierung

Django führt automatisch einige Validierungsprüfungen für Sie durch:

• Pflichtfelder: Standardmäßig sind alle Felder Pflichtfelder, es sei denn, Sie geben required=False an.
• Feldtypen: Felder wie „EmailField“, „IntegerField“ und „URLField“ überprüfen automatisch den Typ der eingegebenen Daten.

Benutzerdefinierte Validierung

Sie können auch eine benutzerdefinierte Validierungslogik definieren, indem Sie die Methode clean() überschreiben oder benutzerdefinierte Feldvalidatoren erstellen.

1. Hinzufügen eines benutzerdefinierten Validators für das Feld „name“:

# forms.py
from django import forms
from django.core.exceptions import ValidationError

class ContactForm(forms.Form):
    name = forms.CharField(max_length=100, label='Your Name')
    email = forms.EmailField(label='Your Email')
    message = forms.CharField(widget=forms.Textarea, label='Your Message')

    def clean_name(self):
        name = self.cleaned_data.get('name')
        if "spam" in name.lower():
            raise ValidationError("Invalid name: 'spam' is not allowed.")
        return name

In diesem Beispiel löst Django einen Validierungsfehler aus, wenn der Name das Wort „spam“ enthält.

2. Behandlung von Formularfehlern in Vorlagen: Sie können die Darstellung von Formularfehlern in Vorlagen individuell anpassen. Django fügt jedem Feld automatisch Fehlermeldungen hinzu, die Sie wie folgt anzeigen können:

<form method="post">
    {% csrf_token %}
    <div>
        {{ form.name.label_tag }} {{ form.name }}
        {% if form.name.errors %}
            <div class="error">{{ form.name.errors }}</div>
        {% endif %}
    </div>
    <div>
        {{ form.email.label_tag }} {{ form.email }}
        {% if form.email.errors %}
            <div class="error">{{ form.email.errors }}</div>
        {% endif %}
    </div>
    <div>
        {{ form.message.label_tag }} {{ form.message }}
        {% if form.message.errors %}
            <div class="error">{{ form.message.errors }}</div>
        {% endif %}
    </div>
    <button type="submit">Send Message</button>
</form>

Dadurch wird sichergestellt, dass Nutzer relevante Fehlermeldungen neben den Feldern sehen, die sie korrigieren müssen.

Erstellen von Formularen aus Modellen mit ModelForm

In vielen Fällen sind Formulare an Modelle gekoppelt. Django erleichtert das direkte Erstellen von Formularen aus Modellen mithilfe von ModelForm. Dies spart Zeit, da Formularfelder automatisch auf der Grundlage der Felder des Modells generiert werden.

1. Erstellen eines ModelForm: Angenommen, Sie haben ein „Post“-Modell in Ihrer Datei „models.py“:

# models.py
from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

Sie können wie folgt ein Formular für dieses Modell erstellen:

# forms.py
from django import forms
from .models import Post

class PostForm(forms.ModelForm):
    class Meta:
        model = Post
        fields = ['title', 'content']

2. Verwendung von ModelForm in einer Ansicht:

# views.py
from django.shortcuts import render
from .forms import PostForm

def create_post(request):
    if request.method == 'POST':
        form = PostForm(request.POST)
        if form.is_valid():
            form.save()  # Saves the form data to the database
            return redirect('post_list')  # Redirect to a list of posts
    else:
        form = PostForm()
    return render(request, 'create_post.html', {'form': form})

Durch die Verwendung von ModelForm generiert Django automatisch Formularfelder auf der Grundlage der Felder des Post-Modells und übernimmt das Speichern des Formulars in der Datenbank.

Bereitstellung einer Django-Anwendung

Sobald Ihre Anwendung vollständig entwickelt und auf Ihrem lokalen Rechner getestet wurde, besteht der letzte Schritt darin, sie auf einem Live-Server bereitzustellen, damit Nutzer darauf zugreifen können. Die Bereitstellung eines Django-Projekts erfordert die sorgfältige Berücksichtigung von Best Practices, um Sicherheit, Skalierbarkeit und Leistung zu gewährleisten. In diesem Abschnitt behandeln wir die wesentlichen Schritte zur Bereitstellung Ihrer Anwendung auf einem VPS, die jeder Django-Entwickler kennen sollte.

Bewährte Vorgehensweisen für die Bereitstellung eines Django-Projekts

Bevor Sie sich mit den technischen Schritten befassen, ist es wichtig, bei der Vorbereitung Ihres Django-Projekts auf die Bereitstellung einige bewährte Vorgehensweisen zu beachten:

1. Verwenden Sie Umgebungsvariablen: Speichern Sie sensible Informationen wie geheime Schlüssel, Datenbank-Anmeldedaten und API-Schlüssel in Umgebungsvariablen, anstatt sie fest in Ihre Einstellungen einzubinden.
2. Deaktivieren Sie den Debug-Modus: Stellen Sie sicher, dass Sie in Ihrer Datei „settings.py“ DEBUG = False festlegen, bevor Sie Ihr Projekt in der Produktion bereitstellen. Der Debug-Modus kann sensible Informationen für Angreifer offenlegen.
3. Legen Sie zulässige Hosts fest: Legen Sie in Ihrer settings.py den Parameter ALLOWED_HOSTS so fest, dass er die Domainnamen enthält, unter denen Ihre App gehostet wird. Zum Beispiel:

ALLOWED_HOSTS = ['yourdomain.com', 'www.yourdomain.com']

4. Sichern Sie die Anwendung: Erwägen Sie die Verwendung von HTTPS für die sichere Kommunikation zwischen dem Server und den Benutzern und nutzen Sie die integrierten Sicherheitseinstellungen von Django wie SECURE_SSL_REDIRECT, CSRF_COOKIE_SECURE und SESSION_COOKIE_SECURE.
5. Lassen Sie statische Dateien verarbeiten: Stellen Sie sicher, dass statische Dateien wie CSS und JavaScript ordnungsgemäß gesammelt und bereitgestellt werden. Django stellt hierfür den Befehlcollectstatic zur Verfügung.
6. Konfigurieren Sie die Datenbank: Stellen Sie sicher, dass die Datenbank ordnungsgemäß konfiguriert ist, und vermeiden Sie die Verwendung von SQLite in der Produktion. Verwenden Sie eine robustere Datenbank wie PostgreSQL oder MySQL.

Bereitstellung von Django auf einem VPS

Nachdem Sie nun die bewährten Vorgehensweisen zur Vorbereitung eines Django-Projekts kennengelernt haben, ist es an der Zeit, es auf einem Virtual Private Server (VPS) bereitzustellen. In diesem Abschnitt führen wir Sie durch die Schritte zur Einrichtung Ihres Servers, zur Konfiguration der erforderlichen Dienste und dazu, Ihre Django-Anwendung live zu schalten und für Benutzer zugänglich zu machen.

Erstellen einer Python-Datei „requirements.txt“

Eine „requirements.txt“-Datei listet alle Python-Abhängigkeiten auf, die Ihr Django-Projekt zur Ausführung benötigt. Mit dieser Datei können Sie alle erforderlichen Pakete mit einem einzigen Befehl installieren.

Stellen Sie sicher, dass Sie sich im Hauptverzeichnis Ihres Projekts befinden, in dem sich die Datei „manage.py“ befindet, und vergewissern Sie sich, dass Ihre virtuelle Umgebung aktiv ist.

Generieren Sie anschließend die Datei „requirements.txt“ mit dem folgenden Befehl:

pip3 freeze > requirements.txt

Dieser Befehl erstellt in Ihrem aktuellen Verzeichnis eine „requirements.txt“-Datei mit allen installierten Paketen und deren Versionen, die sich in Ihrer aktuellen virtuellen Umgebung befinden.

Öffnen Sie anschließend die Datei „requirements.txt“ und vergewissern Sie sich, dass alle für die Ausführung Ihres Projekts erforderlichen Abhängigkeiten aufgeführt sind.

Hochladen des Projekts in ein Remote-Repository (GitHub)

Bevor Sie Ihr Projekt auf einem VPS bereitstellen, empfiehlt es sich, Ihren Code zur Versionskontrolle und zur einfachen Zusammenarbeit in ein Remote-Repository wie GitHub hochzuladen. Außerdem vereinfacht dies den Bereitstellungsprozess selbst.

1. Installieren Sie die Git-CLI und initialisieren Sie ein lokales Repository. Vergewissern Sie sich, dass Sie sich in Ihrem Hauptprojektordner befinden, in dem sich die Datei „manage.py“ befindet, und führen Sie folgende Befehle aus:

sudo apt install git-all

git init

2. Erstellen Sie eine .gitignore-Datei und fügen Sie Inhalte hinzu. Die .gitignore-Datei teilt Git mit, welche Dateien beim Pushen von Code in Ihr Remote-Repository ignoriert werden sollen. Dies geschieht, um zu verhindern, dass Dateien mit sensiblen Informationen sowie lokale, irrelevante Dateien wie Protokolle veröffentlicht werden. Hier ist ein Beispiel für eine.gitignore-Datei für ein Django-Projekt:

venv/
__pycache__/
db.sqlite3
*.pyc
*.log
media/

3. Bereinigen Sie sensible Informationen in Ihrer settings.py. Stellen Sie sicher, dass Sie sensible Informationen in Ihrer settings.py-Datei, wie z. B. Passwörter, Benutzernamen usw., bereinigen. Sobald das Projekt bereitgestellt ist, können Sie die Anmeldedaten zu Ihrem VPS hinzufügen.
4. Fügen Sie Ihre Dateien hinzu und führen Sie ein Commit durch.

git add .

git commit -m "Initial commit"

5. Registrieren Sie sich bei GitHub und erstellen Sie ein Remote-Repository. Rufen Sie GitHub auf und registrieren Sie sich oder melden Sie sich bei Ihrem Konto an. Erstellen Sie ein neues Repository, legen Sie es als privat fest und kopieren Sie den Remote-Link.
6. Richten Sie den Remote-Git-Origin und den Branch ein.

git remote add origin https://github.com/url-to-repository-you-created

git branch -M main

7. Überprüfen Sie den Status Ihres lokalen Repositorys und übertragen Sie die Dateien. Bevor Sie Dateien übertragen, sollten Sie den Befehl „status“ ausführen und sicherstellen, dass keine Dateien hinzugefügt wurden, die Sie nicht übertragen möchten:

git status

Vergewissern Sie sich, dass nur die Dateien hinzugefügt wurden, die Sie hochladen möchten, und übertragen Sie diese in das Remote-Repository:

git push -u origin main 

8. Rufen Sie Ihr Remote-Repository auf GitHub auf und überprüfen Sie die hochgeladenen Dateien.

Bereiten Sie Ihren VPS vor und laden Sie den Projektcode herunter

Als Nächstes müssen Sie Ihren VPS für die Bereitstellung vorbereiten und Ihren Code darauf herunterladen:

1. Stellen Sie eine SSH-Verbindung zu Ihrem VPS her

ssh root@Ihre_VPS-IP

2. Installieren Sie Nginx und Gunicorn

sudo apt install nginx

sudo pip3 install gunicorn

Wir verwenden Nginx als Webserver und Gunicorn als Anwendungsserver

3. Rufen Sie Code von GitHub ab

git clone https://github.com/your-repository/project-name.git

cd Projektname

4. Starten Sie eine virtuelle Umgebung und installieren Sie die Abhängigkeiten

python3 -m venv env_name source env_name/bin/activate

pip3 install -r requirements.txt

5. Tragen Sie die bereinigten Daten wieder in Ihre Datei „settings.py“ ein
6. Führen Sie Migrationen durch und stellen Sie statische Dateien bereit

python manage.py migrate

python manage.py collectstatic

7. Richten Sie Gunicorn als Anwendungsserver ein. Erstellen Sie eine Dienstdatei:

sudo nano /etc/systemd/system/gunicorn.service

Fügen Sie die folgende Konfiguration hinzu:

[Unit]
Description=gunicorn daemon
After=network.target

[Service]
User=your-username
Group=www-data
WorkingDirectory=/your/project/directory
ExecStart=/your/project/directory/env_name/bin/gunicorn --access-logfile - --workers 3 --bind unix:/your/project/directory.sock myproject.wsgi:application

[Install]
WantedBy=multi-user.target

Stellen Sie sicher, dass Sie anstelle von „your-username“ und „/your/project/directory“ Ihren tatsächlichen Benutzernamen und den Pfad zu Ihrem Projektverzeichnis eingeben.

8. Starten und aktivieren Sie Gunicorn

sudo systemctl start gunicorn

sudo systemctl enable gunicorn

9. Konfigurieren Sie Nginx als Webserver. Erstellen Sie eine Konfigurationsdatei:

sudo nano /etc/nginx/sites-available/myproject

Fügen Sie die folgende Konfiguration hinzu:

server {
    listen 80;
    server_name yourdomain.com www.yourdomain.com;

    location / {
        proxy_pass http://unix:/your/project/directory/project-name.sock;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    location /static/ {
        alias /your/project/directory/static/;
    }

    location /media/ {
        alias /your/project/directory/media/;
    }
}

Stellen Sie sicher, dass Sie anstelle von /Ihr/Projekt/Verzeichnis Ihren tatsächlichen Verzeichnispfad eingeben.

10. Aktivieren Sie die Website und starten Sie Nginx neu

sudo ln -s /etc/nginx/sites-available/myproject /etc/nginx/sites-enabled

sudo systemctl restart nginx

11. Sichern Sie den Server mit SSL. Wir verwenden Certbot, um ein SSL-Zertifikat zu installieren und den Datenverkehr von HTTP auf HTTPS umzuleiten:

sudo apt install certbot python3-certbot-nginxsudo certbot --nginx -d yourdomain.com -d www.yourdomain.com

Mit diesen Schritten haben Sie Ihre Django-Anwendung erfolgreich auf einem VPS unter Einhaltung bewährter Verfahren bereitgestellt und damit sowohl Sicherheit als auch Leistung gewährleistet.

Da Nginx und Gunicorn nun für den Web- und Anwendungsbetrieb zuständig sind, ist Ihre App bereit, Live-Datenverkehr zu verarbeiten. Rufen Sie Ihre Domain auf – wenn Sie alles richtig eingerichtet haben, sollten Sie Ihre Webanwendung nun live sehen.

Fazit

In diesem Tutorial haben wir die wesentlichen Schritte für den Einstieg in Django behandelt, von der Einrichtung Ihrer Entwicklungsumgebung bis zur Bereitstellung Ihres Projekts auf einem VPS. Sie haben gelernt, wie Sie ein Projekt erstellen, Modelle verwalten und Daten speichern, Ansichten und Vorlagen erstellen, mit URLs arbeiten, statische Dateien handhaben, die Benutzerauthentifizierung implementieren und Ihre Anwendung auf einem Live-Server bereitstellen.

Mit diesen grundlegenden Kenntnissen sind Sie nun bestens gerüstet, um mit der Entwicklung Ihrer eigenen Django-Projekte zu beginnen. Ob es sich um einen einfachen Blog oder eine komplexere Webanwendung handelt – Django bietet Ihnen die Werkzeuge, um Ihre Ideen zum Leben zu erwecken. Tauchen Sie ein, experimentieren Sie und entdecken Sie, was Sie mit diesem leistungsstarken Web-Framework alles erschaffen können.

Häufig gestellte Fragen zum Django-Tutorial

Alle Tutorial-Inhalte auf dieser Website unterliegen Hostingers strengen redaktionellen Standards und Normen.

Erstellt von

Eveline Boschmann

Eveline ist Lokalisierungsexpertin mit langjähriger Erfahrung in der Transkreation von Inhalten für den deutschen Markt. Sie unterstützt Hostinger dabei, die Kernwerte und die Markenbotschaft des Unternehmens an ein internationales Publikum zu vermitteln und Hostingers hochwertige Tutorials für alle zugänglich zu machen.

Mehr von Eveline Boschmann