TOC

So verwenden Sie Postgresql mit Ihrer Django-Anwendung unter Debian 8

Einführung

Django ist ein flexibles Framework zum schnellen Erstellen von Python-Anwendungen. Standardmäßig sind Django-Anwendungen so konfiguriert, dass Daten in einer kompakten SQLite-Datenbankdatei gespeichert werden. Während dies unter bestimmten Belastungen gut funktioniert, kann ein herkömmlicheres DBMS die Leistung in der Produktion verbessern.

In diesem Handbuch wird gezeigt, wie Sie PostgreSQL für Ihre Django-Anwendungen installieren und konfigurieren. Wir werden die erforderliche Software installieren, Datenbankanmeldeinformationen für unsere Anwendung erstellen und dann ein neues Django-Projekt starten und konfigurieren, um dieses Backend zu verwenden.

Voraussetzungen

Zu Beginn benötigen Sie eine saubere Debian 8-Serverinstanz mit einem Nicht-Root-Benutzer. Der Benutzer ohne Rootberechtigung muss mit "+ sudo +" - Berechtigungen konfiguriert sein. Weitere Informationen zum Einrichten finden Sie in unserem initial server setup guide.

Wenn Sie fortfahren möchten, melden Sie sich als Ihr Benutzer "+ sudo +" an und lesen Sie weiter.

Installieren Sie die Komponenten aus den Debian-Repositories

Unser erster Schritt wird sein, alle Teile, die wir brauchen, aus den Repositories zu installieren. Wir werden + pip +, den Python-Paketmanager, installieren, um unsere Python-Komponenten zu installieren und zu verwalten. Wir werden auch die Datenbanksoftware und die zugehörigen Bibliotheken installieren, die für die Interaktion mit ihnen erforderlich sind.

Für Python 2 und Python 3 sind geringfügig unterschiedliche Pakete erforderlich. Wählen Sie daher die Befehle aus, die der Python-Version Ihres Projekts entsprechen.

Wenn Sie * Python 2 * verwenden, geben Sie Folgendes ein:

sudo apt-get update
sudo apt-get install python-pip python-dev libpq-dev postgresql postgresql-contrib

Wenn Sie * Python 3 * verwenden, geben Sie Folgendes ein:

sudo apt-get update
sudo apt-get install python3-pip python3-dev libpq-dev postgresql postgresql-contrib

Mit der Installation können wir fortfahren, um unsere Datenbank und den Datenbankbenutzer zu erstellen.

Erstellen Sie eine Datenbank und einen Datenbankbenutzer

Standardmäßig verwendet Postgres ein Authentifizierungsschema mit der Bezeichnung "Peer-Authentifizierung" für lokale Verbindungen. Grundsätzlich bedeutet dies, dass sich der Benutzer ohne weitere Authentifizierung anmelden kann, wenn der Benutzername des Betriebssystems des Benutzers mit einem gültigen Postgres-Benutzernamen übereinstimmt.

Während der Postgres-Installation wurde ein Betriebssystembenutzer mit dem Namen "+ postgres " erstellt, der dem administrativen Benutzer " postgres " PostgreSQL entspricht. Wir müssen diesen Benutzer verwenden, um administrative Aufgaben auszuführen. Wir können ` sudo ` verwenden und den Benutzernamen mit der Option ` -u +` übergeben.

Melden Sie sich bei einer interaktiven Postgres-Sitzung an, indem Sie Folgendes eingeben:

sudo -u postgres psql

Zunächst erstellen wir eine Datenbank für unser Django-Projekt. Jedes Projekt sollte aus Sicherheitsgründen eine eigene isolierte Datenbank haben. Wir werden unsere Datenbank in diesem Handbuch "++" nennen, aber es ist immer besser, etwas aussagekräftigeres für echte Projekte auszuwählen:

CREATE DATABASE ;
OutputCREAT DATABASE

Als Nächstes erstellen wir einen Datenbankbenutzer, mit dem wir eine Verbindung zur Datenbank herstellen und mit dieser interagieren. Stellen Sie das Passwort auf etwas Starkes und Sicheres ein:

CREATE USER  WITH PASSWORD '';
OutputCREATE ROLE

Als Nächstes ändern wir einige der Verbindungsparameter für den soeben erstellten Benutzer. Dies beschleunigt die Datenbankoperationen, da nicht bei jedem Verbindungsaufbau die richtigen Werte abgefragt und eingestellt werden müssen.

Wir setzen die Standardkodierung auf UTF-8, das von Django erwartete Format. Wir setzen außerdem das Standard-Transaktionsisolationsschema auf "read commit", wodurch Lesevorgänge für nicht festgeschriebene Transaktionen blockiert werden. Zuletzt stellen wir die Zeitzone ein. Standardmäßig verwenden Ihre Django-Projekte "+ UTC". Dies sind alles Empfehlungen von das Django-Projekt selbst.

ALTER ROLE  SET client_encoding TO 'utf8';
ALTER ROLE  SET default_transaction_isolation TO 'read committed';
ALTER ROLE  SET timezone TO 'UTC';
OutputALTER ROLE
ALTER ROLE
ALTER ROLE

Jetzt müssen wir unseren Datenbankbenutzern nur noch Zugriffsrechte auf die von uns erstellte Datenbank gewähren:

GRANT ALL PRIVILEGES ON DATABASE  TO ;
OutputGRANT

Beenden Sie die SQL-Eingabeaufforderung, wenn Sie fertig sind.

\q

Sie sollten jetzt zu Ihrer vorherigen Shell-Sitzung zurückkehren.

Installieren Sie Django in einer virtuellen Umgebung

Nachdem unsere Datenbank eingerichtet ist, können wir Django installieren. Zur Verbesserung der Flexibilität werden wir Django und alle seine Abhängigkeiten in einer virtuellen Python-Umgebung installieren. Mit dem Paket "+ virtualenv +" können Sie diese Umgebungen einfach erstellen.

Wenn Sie * Python 2 * verwenden, können Sie das richtige Paket installieren, indem Sie Folgendes eingeben:

sudo pip install virtualenv

Wenn Sie * Python 3 * verwenden, können Sie das richtige Paket installieren, indem Sie Folgendes eingeben:

sudo pip3 install virtualenv

Erstellen Sie ein Verzeichnis, in dem sich Ihr Django-Projekt befindet:

mkdir ~/
cd ~/

Wir können eine virtuelle Umgebung zum Speichern der Python-Anforderungen Ihres Django-Projekts erstellen, indem wir Folgendes eingeben:

virtualenv

Dies installiert eine lokale Kopie von Python und einen lokalen "+ pip " - Befehl in ein Verzeichnis mit dem Namen "+" in Ihrem Projektverzeichnis.

Bevor wir Anwendungen in der virtuellen Umgebung installieren, müssen wir sie aktivieren. Sie können dies tun, indem Sie Folgendes eingeben:

source /bin/activate

Ihre Eingabeaufforderung ändert sich und zeigt an, dass Sie jetzt in der virtuellen Umgebung arbeiten. Es wird ungefähr so ​​aussehen: + () @: ~ / $ +.

Sobald Ihre virtuelle Umgebung aktiv ist, können Sie Django mit + pip + installieren. Wir werden auch das Paket + psycopg2 + installieren, mit dem wir die von uns konfigurierte Datenbank verwenden können:

Note

pip install django psycopg2

Wir können jetzt ein Django-Projekt in unserem + myproject + Verzeichnis starten. Dadurch wird ein gleichnamiges untergeordnetes Verzeichnis erstellt, in dem sich der Code selbst befindet, und im aktuellen Verzeichnis wird ein Verwaltungsskript erstellt:

django-admin.py startproject  .

Ihre aktuelle Verzeichnisstruktur sollte ungefähr so ​​aussehen:

.
└── ./myproject/
   ├── manage.py
   ├── myproject/
   │   ├── __init__.py
   │   ├── settings.py
   │   ├── urls.py
   │   └── wsgi.py
   └── venv/
       └── . . .

Wie Sie sehen, haben wir ein übergeordnetes Projektverzeichnis, das ein Skript "+ manage.py" enthält, ein inneres Projektverzeichnis und das virtuelle Umgebungsverzeichnis "+ venv", das wir zuvor erstellt haben.

Konfigurieren Sie die Django-Datenbankeinstellungen

Nachdem wir ein Projekt haben, müssen wir es konfigurieren, um die von uns erstellte Datenbank zu verwenden.

Öffnen Sie die Einstellungsdatei für das Django-Hauptprojekt, die sich im untergeordneten Projektverzeichnis befindet:

nano ~///settings.py

Bevor wir die Datenbank einrichten, müssen Sie möglicherweise auch die Direktive + ALLOWED_HOSTS + anpassen. Dies definiert eine Whitelist mit Adressen oder Domänennamen, die zum Herstellen einer Verbindung mit der Django-Instanz verwendet werden können. Alle eingehenden Anforderungen mit einem * Host * -Header, der nicht in dieser Liste enthalten ist, lösen eine Ausnahme aus. Django erfordert, dass Sie dies einstellen, um eine bestimmte Sicherheitslücke zu vermeiden.

Listen Sie in den eckigen Klammern die IP-Adressen oder Domänennamen auf, die Ihrem Django-Server zugeordnet sind. Jeder Artikel sollte in Anführungszeichen * mit durch Komma * getrennten Einträgen * aufgeführt werden. Wenn Sie auf Anfragen nach einer Domain und Subdomains antworten möchten, stellen Sie einen Punkt vor den Anfang des Eintrags. Im folgenden Snippet sind einige Beispiele auskommentiert, um die korrekte Formatierung von Einträgen zu demonstrieren:

~ / myproject / myproject / settings.py

. . .
# The simplest case: just add the domain name(s) and IP addresses of your Django server
# ALLOWED_HOSTS = [ 'example.com', '203.0.113.5']
# To respond to 'example.com' and any subdomains, start the domain with a dot
# ALLOWED_HOSTS = ['.example.com', '203.0.113.5']
ALLOWED_HOSTS = ['', '', ]

Suchen Sie als nächstes den Abschnitt "+ DATABASES +", der so aussieht:

~ / myproject / myproject / settings.py

. . .

DATABASES = {
   'default': {
       'ENGINE': 'django.db.backends.sqlite3',
       'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
   }
}

. . .

Dies ist derzeit so konfiguriert, dass SQLite als Datenbank verwendet wird. Wir müssen dies ändern, damit stattdessen unsere PostgreSQL-Datenbank verwendet wird.

Ändern Sie zunächst die Engine so, dass der Adapter + postgresql_psycopg2 + anstelle des Adapters + sqlite3 + verwendet wird. Verwenden Sie für "+ NAME " den Namen Ihrer Datenbank (in unserem Beispiel "+"). Wir müssen auch Anmeldeinformationen hinzufügen. Wir benötigen den Benutzernamen, das Passwort und den Host, um eine Verbindung herzustellen. Wir werden die Port-Option hinzufügen und leer lassen, damit die Standardeinstellung ausgewählt wird:

~ / myproject / myproject / settings.py

. . .

DATABASES = {
   'default': {
       'ENGINE': 'django.db.backends.',
       'NAME': '',
       'USER': '',
       'PASSWORD': '',
       'HOST': 'localhost',
       'PORT': '',
   }
}

. . .

Wenn Sie fertig sind, speichern und schließen Sie die Datei.

Migrieren Sie die Datenbank und testen Sie Ihr Projekt

Nachdem die Django-Einstellungen konfiguriert wurden, können wir unsere Datenstrukturen in unsere Datenbank migrieren und den Server testen.

Wir können damit beginnen, Migrationen zu erstellen und auf unsere Datenbank anzuwenden. Da wir noch keine tatsächlichen Daten haben, wird hiermit einfach die anfängliche Datenbankstruktur eingerichtet:

cd ~/
./manage.py makemigrations
./manage.py migrate

Nach dem Erstellen der Datenbankstruktur können wir ein Administratorkonto erstellen, indem wir Folgendes eingeben:

./manage.py createsuperuser

Sie werden aufgefordert, einen Benutzernamen auszuwählen, eine E-Mail-Adresse anzugeben und ein Kennwort für das Konto auszuwählen und zu bestätigen.

Als Nächstes können Sie testen, ob Ihre Datenbank ordnungsgemäß funktioniert, indem Sie den Django-Entwicklungsserver starten:

./manage.py runserver 0.0.0.0:8000

Besuchen Sie in Ihrem Webbrowser den Domainnamen oder die IP-Adresse Ihres Servers, gefolgt von "+: 8000 +", um die Standard-Django-Root-Seite zu erreichen:

http://:8000

Sie sollten die Standardindexseite sehen:

image: https://assets.digitalocean.com/articles/django_mysql_1404/django_index.png [Django index]

Fügen Sie "+ / admin +" an das Ende der URL an und Sie sollten in der Lage sein, auf den Anmeldebildschirm der Admin-Oberfläche zuzugreifen:

Bild: https://assets.digitalocean.com/articles/django_mysql_1404/admin_login.png [Django-Administratoranmeldung]

Geben Sie den Benutzernamen und das Passwort ein, die Sie gerade mit dem Befehl + createduperuser + erstellt haben. Sie werden dann zur Administrationsoberfläche weitergeleitet:

Bild: https://assets.digitalocean.com/articles/django_mysql_1404/admin_interface.png [Django-Administrationsoberfläche]

Wenn Sie mit den Nachforschungen fertig sind, können Sie den Entwicklungsserver stoppen, indem Sie in Ihrem Terminalfenster STRG-C drücken.

Durch den Zugriff auf die Administrationsoberfläche haben wir bestätigt, dass in unserer Datenbank unsere Benutzerkontoinformationen gespeichert sind und dass auf diese entsprechend zugegriffen werden kann.

Wir können dies weiter überprüfen, indem wir die Postgres-Datenbank selbst mit dem Client + psql + abfragen. Zum Beispiel können wir eine Verbindung zu unserer Projektdatenbank ("+ myproject ") mit dem Benutzer unseres Projekts (" myprojectuser +") herstellen und alle verfügbaren Tabellen ausdrucken, indem wir Folgendes eingeben:

psql -W   -h 127.0.0.1 -f <(echo '\dt')

Das + -W + Flag veranlasst + psql + Sie zur Eingabe des entsprechenden Passworts. Wir müssen das "+ -h " - Flag explizit verwenden, um eine Verbindung zum lokalen Host über das Netzwerk herzustellen, um anzuzeigen, dass wir die Kennwortauthentifizierung anstelle der Peerauthentifizierung verwenden möchten. Wir verwenden das Flag " -f ", um den auszuführenden " psql " -Meta-Befehl " \ dt +" zu übergeben, der alle Tabellen in der Datenbank auflistet:

Output                      List of relations
Schema |            Name            | Type  |     Owner
--------+----------------------------+-------+---------------
public | auth_group                 | table | myprojectuser
public | auth_group_permissions     | table | myprojectuser
public | auth_permission            | table | myprojectuser
public | auth_user                  | table | myprojectuser
public | auth_user_groups           | table | myprojectuser
public | auth_user_user_permissions | table | myprojectuser
public | django_admin_log           | table | myprojectuser
public | django_content_type        | table | myprojectuser
public | django_migrations          | table | myprojectuser
public | django_session             | table | myprojectuser
(10 rows)

Wie Sie sehen, hat Django einige Tabellen in unserer Datenbank erstellt, die bestätigen, dass unsere Einstellungen gültig sind.

Fazit

In diesem Handbuch wird gezeigt, wie Sie PostgreSQL als Backend-Datenbank für ein Django-Projekt installieren und konfigurieren. Während SQLite die Last während der Entwicklung und der Light Production-Nutzung problemlos bewältigen kann, profitieren die meisten Projekte von der Implementierung eines umfassenderen DBMS.

Related