So richten Sie eine skalierbare Django-App mit von DigitalOcean verwalteten Datenbanken und Spaces ein

Einführung

Django ist ein leistungsstarkes Webframework, mit dem Sie Ihre Python-Anwendung oder Website schnell auf den Markt bringen können. Es enthält mehrere praktische Funktionen wieobject-relational mapper, eine Python-API und eine anpassbare Verwaltungsoberfläche für Ihre Anwendung. Es enthält auchcaching framework und fördert das saubere App-Design durchURL Dispatcher undTemplate system.

Im Lieferumfang von Django ist ein minimaler Webserver zum Testen und für die lokale Entwicklung enthalten. Er sollte jedoch mit einer stabileren Serving-Infrastruktur für Produktionsanwendungsfälle kombiniert werden. Django wird häufig mit einem Nginx-Webserver zur Verarbeitung statischer Dateianforderungen und HTTPS-Umleitung sowie einemGunicorn WSGI-Server zur Bereitstellung der App bereitgestellt.

In diesem Handbuch werden wir dieses Setup erweitern, indem wir statische Dateien wie Javascript und CSS-Stylesheets in DigitalOcean Spaces auslagern und optional mit einemC-SontentDeliveryN-Setwork oder CDN bereitstellen, in dem diese gespeichert sind Dateien, die näher am Endbenutzer liegen, um die Übertragungszeiten zu verkürzen. Wir werden auch DigitalOceanManaged PostgreSQL database als Datenspeicher verwenden, um die Datenschicht zu vereinfachen und zu vermeiden, dass eine skalierbare PostgreSQL-Datenbank manuell konfiguriert werden muss.

Voraussetzungen

Bevor Sie mit diesem Handbuch beginnen, sollten Sie Folgendes zur Verfügung haben:

Eine neue Ubuntu 18.04-Serverinstanz mit einer grundlegenden Firewall und einem Nicht-Root-Benutzer mit konfiguriertensudo-Berechtigungen. Sie können lernen, wie Sie dies einrichten, indem SieInitial Server Setup with Ubuntu 18.04 durchlaufen.
Ein von DigitalOcean verwaltetes PostgreSQL-Cluster. Informationen zum Erstellen eines Clusters finden Sie in DigitalOceanManaged Databases product documentation.
Ein DigitalOcean Space zum Speichern Ihrer statischen Django-Projektdateien und eines Satzes von Zugriffsschlüsseln für diesen Space. Informationen zum Erstellen eines Space finden Sie in der Produktdokumentation vonHow to Create Spaces. Informationen zum Erstellen von Zugriffsschlüsseln für Spaces finden Sie inSharing Access to Spaces with Access Keys.
Nginx wurde auf Ihrem Server installiert, gesichert und so konfiguriert, dass es mit einem Domainnamen Ihrer Wahl funktioniert. Weitere Informationen zum Einrichten von A-Datensätzen und zum Sichern Ihrer Nginx-Installation mitLet’s Encrypt finden Sie unterHow To Secure Nginx with Let’s Encrypt on Ubuntu 18.04.

[[Schritt-1 - Installieren von Paketen aus den Ubuntu-Repositorys]] == Schritt 1 - Installieren von Paketen aus den Ubuntu-Repositorys

Zunächst laden wir alle benötigten Elemente aus den Ubuntu-Repositorys herunter und installieren sie. Wir werden den Python-Paketmanagerpip verwenden, um zusätzliche Komponenten etwas später zu installieren.

Wir müssen zuerst den lokalenapt-Paketindex aktualisieren und dann die Pakete herunterladen und installieren.

In diesem Handbuch verwenden wir Django mitPython 3. Melden Sie sich bei Ihrem Server an und geben Sie Folgendes ein, um die erforderlichen Bibliotheken zu installieren:

sudo apt update
sudo apt install python3-pip python3-dev libpq-dev curl postgresql-client

Dadurch werdenpip, die zum Erstellen von Gunicorn erforderlichen Python-Entwicklungsdateien, die zum Erstellen des PostgreSQL-Python-Adapters vonPyscopgerforderlichen libpq-Header-Dateien und der PostgreSQL-Befehlszeilenclient installiert.

Drücken SieY und dannENTER, wenn Sie aufgefordert werden, die Pakete herunterzuladen und zu installieren.

Als Nächstes konfigurieren wir die Datenbank für die Verwendung mit unserer Django-App.

[[Schritt-2 - Erstellen der Postgresql-Datenbank und des Benutzers]] == Schritt 2 - Erstellen der PostgreSQL-Datenbank und des Benutzers

Wir erstellen jetzt eine Datenbank und einen Datenbankbenutzer für unsere Django-Anwendung.

Holen Sie sich zunächst dieConnection Parameters für Ihren Cluster, indem Sie vonCloud Control Panel zuDatabases navigieren und in Ihre Datenbank klicken. Sie sollten einConnection Details-Feld sehen, das einige Parameter für Ihren Cluster enthält. Notieren Sie diese.

Melden Sie sich in der Befehlszeile mit diesen Anmeldeinformationen und dem soeben installierten PostgreSQL-Client vonpsqlbei Ihrem Cluster an:

psql -U username -h host -p port -d database -set=sslmode=require

Wenn Sie dazu aufgefordert werden, geben Sie das neben dem Postgres-Benutzernamen angezeigte Kennwort ein und drücken SieENTER.

Sie erhalten eine PostgreSQL-Eingabeaufforderung, über die Sie die Datenbank verwalten können.

Erstellen Sie zunächst eine Datenbank für Ihr Projekt mit dem Namenpolls:

CREATE DATABASE polls;

[.note] #Note: Jede Postgres-Anweisung muss mit einem Semikolon enden. Stellen Sie daher sicher, dass Ihr Befehl mit einem endet, wenn Probleme auftreten.
#

Wir können jetzt zur Datenbankpollswechseln:

\c polls;

Erstellen Sie als Nächstes einen Datenbankbenutzer für das Projekt. Stellen Sie sicher, dass Sie ein sicheres Passwort wählen:

CREATE USER myprojectuser WITH PASSWORD 'password';

Wir werden nun einige der Verbindungsparameter für den soeben erstellten Benutzer ändern. Dies beschleunigt die Datenbankoperationen, sodass nicht bei jedem Verbindungsaufbau die richtigen Werte abgefragt und eingestellt werden müssen.

Wir setzen die Standardcodierung aufUTF-8, was Django erwartet. 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 unsere Django-ProjekteUTC. Dies sind alles Empfehlungen vonthe Django project itself.

Geben Sie die folgenden Befehle an der PostgreSQL-Eingabeaufforderung ein:

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

Jetzt können wir unserem neuen Benutzer den Zugriff auf die Verwaltung unserer neuen Datenbank gewähren:

GRANT ALL PRIVILEGES ON DATABASE polls TO myprojectuser;

Wenn Sie fertig sind, beenden Sie die PostgreSQL-Eingabeaufforderung, indem Sie Folgendes eingeben:

\q

Ihre Django-App kann jetzt eine Verbindung zu dieser Datenbank herstellen und diese verwalten.

Im nächsten Schritt installieren wirvirtualenv und erstellen eine virtuelle Python-Umgebung für unser Django-Projekt.

[[Schritt 3 - Erstellen einer virtuellen Python-Umgebung für Ihr Projekt]] == Schritt 3 - Erstellen einer virtuellen Python-Umgebung für Ihr Projekt

Nachdem wir unsere Datenbank für die Verwendung mit unserer Anwendung eingerichtet haben, erstellen wir eine virtuelle Python-Umgebung, die die Abhängigkeiten dieses Projekts von der globalen Python-Installation des Systems isoliert.

Dazu benötigen wir zunächst Zugriff auf den Befehlvirtualenv. Wir können dies mitpip installieren.

Aktualisieren Siepip und installieren Sie das Paket, indem Sie Folgendes eingeben:

sudo -H pip3 install --upgrade pip
sudo -H pip3 install virtualenv

Wennvirtualenv installiert ist, können wir ein Verzeichnis zum Speichern unserer virtuellen Python-Umgebungen erstellen und eines für die Verwendung mit der App von Djangopollserstellen.

Erstellen Sie ein Verzeichnis mit dem Namenenvs und navigieren Sie hinein:

mkdir envs
cd envs

Erstellen Sie in diesem Verzeichnis eine virtuelle Python-Umgebung mit dem Namenpolls, indem Sie Folgendes eingeben:

virtualenv polls

Dadurch wird ein Verzeichnis mit dem Namenpolls im Verzeichnisenvs erstellt. Im Inneren wird eine lokale Version von Python und eine lokale Version vonpip installiert. Damit können wir eine isolierte Python-Umgebung für unser Projekt installieren und konfigurieren.

Bevor wir die Python-Anforderungen unseres Projekts installieren, müssen wir die virtuelle Umgebung aktivieren. Sie können dies tun, indem Sie Folgendes eingeben:

source polls/bin/activate

Ihre Eingabeaufforderung sollte sich ändern, um anzuzeigen, dass Sie jetzt in einer virtuellen Python-Umgebung arbeiten. Es sieht ungefähr so aus:(polls)user@host:~/envs$.

Installieren Sie bei aktivierter virtueller Umgebung Django, Gunicorn und den PostgreSQL-Adapterpsycopg2 mit der lokalen Instanzpip:

[.note] #Note: Wenn die virtuelle Umgebung aktiviert ist (wenn Ihrer Eingabeaufforderung(polls) vorangestellt ist), verwenden Siepip anstelle vonpip3, auch wenn Sie Python verwenden 3. Die Kopie des Tools in der virtuellen Umgebung heißt unabhängig von der Python-Version immerpip.
#

pip install django gunicorn psycopg2-binary

Sie sollten jetzt über die gesamte Software verfügen, die Sie zum Ausführen der Djangopolls-App benötigen. Im nächsten Schritt erstellen wir ein Django-Projekt und installieren diese App.

[[Schritt-4 - Erstellen der Polls-Django-Anwendung]] == Schritt 4 - Erstellen der Polls-Django-Anwendung

Wir können jetzt unsere Beispielanwendung einrichten. In diesem Tutorial verwenden wir die Demo-Anwendung "Umfragen" ausDjango documentation. Es besteht aus einer öffentlichen Site, auf der Benutzer Umfragen anzeigen und abstimmen können, und einem Verwaltungsbedienfeld, in dem der Administrator Umfragen ändern, erstellen und löschen kann.

In diesem Handbuch überspringen wir die Schritte des Tutorials und klonen einfach die endgültige Anwendung aus der DigitalOcean Communitydjango-polls repo.

Wenn Sie die Schritte manuell ausführen möchten, erstellen Sie ein Verzeichnis mit dem Namendjango-polls in Ihrem Ausgangsverzeichnis und navigieren Sie darin:

cd
mkdir django-polls
cd django-polls

Von dort aus können Sie dem Tutorial vonWriting your first Django appaus der offiziellen Django-Dokumentation folgen. Wenn Sie fertig sind, fahren Sie mitStep 5 fort.

Wenn Sie nur die fertige App klonen möchten, navigieren Sie zu Ihrem Ausgangsverzeichnis und verwenden Siegit, um diedjango-polls repo zu klonen:

cd
git clone https://github.com/do-community/django-polls.git

cd hinein und liste den Verzeichnisinhalt auf:

cd django-polls
ls

Sie sollten die folgenden Objekte sehen:

OutputLICENSE  README.md  manage.py  mysite  polls  templates

manage.py ist das Hauptbefehlszeilenprogramm, mit dem die App bearbeitet wird. polls enthält den App-Code vonpollsundmysite enthält Code und Einstellungen für den Projektbereich. templates enthält benutzerdefinierte Vorlagendateien für die Verwaltungsoberfläche. Weitere Informationen zur Projektstruktur und zu den Dateien finden Sie inCreating a Project in der offiziellen Django-Dokumentation.

Bevor wir die App ausführen, müssen wir ihre Standardeinstellungen anpassen und sie mit unserer Datenbank verbinden.

[[Schritt-5 - Anpassen der App-Einstellungen]] == Schritt 5 - Anpassen der App-Einstellungen

In diesem Schritt ändern wir die Standardkonfiguration des Django-Projekts, um die Sicherheit zu erhöhen, verbinden Django mit unserer Datenbank und sammeln statische Dateien in einem lokalen Verzeichnis.

Öffnen Sie zunächst die Einstellungsdatei in Ihrem Texteditor:

nano ~/django-polls/mysite/settings.py

Suchen Sie zunächst die DirektiveALLOWED_HOSTS. Dies definiert eine Liste der Adressen oder Domainnamen, die Sie zum Herstellen einer Verbindung mit der Django-Instanz verwenden möchten. Eine eingehende Anforderung mit einemHost-Header, der nicht in dieser Liste enthalten ist, löst eine Ausnahme aus. Django erfordert, dass Sie dies einstellen, um eincertain class of security vulnerability zu verhindern.

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. Ihre Liste enthält auchlocalhost, da Sie Verbindungen über eine lokale Nginx-Instanz übertragen. Wenn Sie Anforderungen für eine gesamte Domain und alle Unterdomänen einschließen möchten, stellen Sie einen Punkt vor den Anfang des Eintrags.

Im folgenden Snippet sind einige Beispiele auskommentiert, die veranschaulichen, wie diese Einträge aussehen sollten:

~/django-polls/mysite/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 = ['your_server_domain_or_IP', 'second_domain_or_IP', . . ., 'localhost']

. . .

Suchen Sie als Nächstes den Abschnitt der Datei, der den Datenbankzugriff konfiguriert. Es beginnt mitDATABASES. Die Konfiguration in der Datei bezieht sich auf eine SQLite-Datenbank. Wir haben bereits eine PostgreSQL-Datenbank für unser Projekt erstellt, daher müssen wir diese Einstellungen anpassen.

Wir werden Django anweisen, anstelle der Standard-SQLite-Engine den Datenbankadapterpsycopg2zu verwenden, den wir mitpip installiert haben. Wir werden auch die inStep 2 angegebenenConnection Parameters wiederverwenden. Sie finden diese Informationen immer im Abschnitt Verwaltete Datenbanken der DigitalOceanCloud Control Panel.

Aktualisieren Sie die Datei mit Ihren Datenbankeinstellungen: dem Datenbanknamen (polls), dem Datenbankbenutzernamen, dem Kennwort des Datenbankbenutzers sowie der Datenbankhost undport. Stellen Sie sicher, dass Sie die datenbankspezifischen Werte durch Ihre eigenen Informationen ersetzen:

~/django-polls/mysite/settings.py

. . .

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'polls',
        'USER': 'myprojectuser',
        'PASSWORD': 'password',
        'HOST': 'managed_db_host',
        'PORT': 'managed_db_port',
    }
}

. . .

Bewegen Sie sich als Nächstes zum Ende der Datei und fügen Sie eine Einstellung hinzu, die angibt, wo die statischen Dateien abgelegt werden sollen. Dies ist erforderlich, damit Nginx Anfragen für diese Artikel bearbeiten kann. Die folgende Zeile weist Django an, sie in einem Verzeichnis namensstatic im Basisprojektverzeichnis abzulegen:

~/django-polls/mysite/settings.py

. . .

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

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Zu diesem Zeitpunkt haben Sie die Einstellungen für die Datenbank, die Sicherheit und die statischen Dateien des Django-Projekts konfiguriert. Wenn Sie das Tutorial vonpollsvon Anfang an befolgt und das GitHub-Repo nicht geklont haben, können Sie mitStep 6 fortfahren. Wenn Sie das GitHub-Repo geklont haben, bleibt ein weiterer Schritt übrig.

Die Django-Einstellungsdatei enthält eineSECRET_KEY-Variable, mit der Hashes für verschiedene Django-Objekte erstellt werden. Es ist wichtig, dass ein eindeutiger, unvorhersehbarer Wert festgelegt wird. Die VariableSECRET_KEY wurde aus dem GitHub-Repository entfernt. Daher erstellen wir eine neue Variable mit einer Funktion, die in das Python-Paketdjango mit dem Namenget_random_secret_key() integriert ist. Öffnen Sie über die Befehlszeile einen Python-Interpreter:

python

Sie sollten die folgende Ausgabe und Eingabeaufforderung sehen:

OutputPython 3.6.7 (default, Oct 22 2018, 11:32:17)
[GCC 8.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

Importieren Sie die Funktionget_random_secret_key aus dem Django-Paket und rufen Sie die Funktion auf:

from django.core.management.utils import get_random_secret_key
get_random_secret_key()

Kopieren Sie den resultierenden Schlüssel in Ihre Zwischenablage.

Beenden Sie den Python-Interpreter, indem SieCTRL+D drücken.

Öffnen Sie anschließend die Einstellungsdatei in Ihrem Texteditor erneut:

nano ~/django-polls/mysite/settings.py

Suchen Sie die VariableSECRET_KEYund fügen Sie den soeben generierten Schlüssel ein:

~/django-polls/mysite/settings.py

. . .

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'your_secret_key_here'

. . .

Speichern und schließen Sie die Datei.

Jetzt testen wir die App lokal auf dem Django-Entwicklungsserver, um sicherzustellen, dass alles richtig konfiguriert ist.

[[Schritt-6 - Testen der App]] == Schritt 6 - Testen der App

Bevor wir den Django-Entwicklungsserver ausführen, müssen wir das Dienstprogrammmanage.pyverwenden, um das Datenbankschema zu erstellen und statische Dateien im VerzeichnisSTATIC_ROOTzu sammeln.

Navigieren Sie in das Basisverzeichnis des Projekts und erstellen Sie das erste Datenbankschema in unserer PostgreSQL-Datenbank mit den Befehlenmakemigrations undmigrate:

cd django-polls
./manage.py makemigrations
./manage.py migrate

makemigrations erstellt die Migrationen oder Änderungen des Datenbankschemas basierend auf den Änderungen, die an Django-Modellen vorgenommen wurden. migrate wendet diese Migrationen auf das Datenbankschema an. Weitere Informationen zu Migrationen in Django finden Sie inMigrations in der offiziellen Django-Dokumentation.

Erstellen Sie einen Administrator für das Projekt, indem Sie Folgendes eingeben:

./manage.py createsuperuser

Sie müssen einen Benutzernamen auswählen, eine E-Mail-Adresse angeben und ein Passwort auswählen und bestätigen.

Wir können den gesamten statischen Inhalt in dem von uns konfigurierten Verzeichnis speichern, indem wir Folgendes eingeben:

./manage.py collectstatic

Die statischen Dateien werden dann in einem Verzeichnis namensstatic in Ihrem Projektverzeichnis abgelegt.

Wenn Sie die anfängliche Anleitung zur Serverkonfiguration befolgt haben, sollte Ihr Server durch eine UFW-Firewall geschützt sein. Zum Testen des Entwicklungsservers müssen wir den Zugriff auf den von uns verwendeten Port zulassen.

Erstellen Sie eine Ausnahme für Port8000, indem Sie Folgendes eingeben:

sudo ufw allow 8000

Testen der App mit dem Django Development Server

Zuletzt können Sie Ihr Projekt testen, indem Sie den Django-Entwicklungsserver mit folgendem Befehl 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 und dem Pfad vonpolls:

http://server_domain_or_IP:8000/polls

Sie sollten die Benutzeroberfläche der Polls-App sehen:

Polls App Interface

Besuchen Sie zum Auschecken der Administrationsoberfläche den Domänennamen oder die IP-Adresse Ihres Servers, gefolgt von:8000 und dem Pfad der Verwaltungsschnittstelle:

http://server_domain_or_IP:8000/admin

Das Fenster für die Administratorauthentifizierung der Polls-App sollte angezeigt werden:

Polls Admin Auth Page

Geben Sie den Administrator-Benutzernamen und das Kennwort ein, die Sie mit dem Befehlcreatesuperuser erstellt haben.

Nach der Authentifizierung können Sie auf die Verwaltungsoberfläche der Polls-App zugreifen:

Polls Admin Main Interface

Wenn Sie mit dem Erkunden fertig sind, drücken Sie im TerminalfensterCTRL-C, um den Entwicklungsserver herunterzufahren.

Testen der App mit Gunicorn

Das Letzte, was wir vor dem Auslagern statischer Dateien tun möchten, ist Gunicorn zu testen, um sicherzustellen, dass es die Anwendung bedienen kann. Wir können dies tun, indem wir unser Projektverzeichnis eingeben undgunicorn verwenden, um das WSGI-Modul des Projekts zu laden:

gunicorn --bind 0.0.0.0:8000 mysite.wsgi

Dadurch wird Gunicorn auf derselben Oberfläche gestartet, auf der der Django-Entwicklungsserver ausgeführt wurde. Sie können die App erneut testen.

[.note] #Note: Auf die Administrationsoberfläche wird kein Styling angewendet, da Gunicorn nicht weiß, wie der dafür verantwortliche statische CSS-Inhalt zu finden ist.
#

Wir haben Gunicorn ein Modul übergeben, indem wir den relativen Verzeichnispfad zu Djangoswsgi.py-Datei angegeben haben, dem Einstiegspunkt für unsere Anwendung. Diese Datei definiert eine Funktion namensapplication, die mit der Anwendung kommuniziert. Um mehr über die WSGI-Spezifikation zu erfahren, klicken Sie aufhere.

Wenn Sie mit dem Testen fertig sind, drücken SieCTRL-C im Terminalfenster, um Gunicorn zu stoppen.

Jetzt werden die statischen Dateien der Anwendung in DigitalOcean Spaces ausgelagert.

[[Schritt-7 - Auslagern statischer Dateien in digitale Räume]] == Schritt 7 - Ausladen statischer Dateien in DigitalOcean-Räume

Zu diesem Zeitpunkt kann Gunicorn unsere Django-Anwendung bedienen, jedoch nicht deren statische Dateien. Normalerweise konfigurieren wir Nginx so, dass diese Dateien bereitgestellt werden. In diesem Lernprogramm werden sie jedoch mithilfe des Pluginsdjango-storagesin DigitalOcean Spaces ausgelagert. Auf diese Weise können Sie Django einfach skalieren, indem Sie den statischen Inhalt zentralisieren und Serverressourcen freigeben. Darüber hinaus können Sie diesen statischen Inhalt mit dem CDN von DigitalOcean Spaces bereitstellen.

Eine vollständige Anleitung zum Auslagern statischer Django-Dateien in den Objektspeicher finden Sie unterHow to Set Up Object Storage with Django.

`django-storages` installieren und konfigurieren

Wir beginnen mit der Installation des Python-Paketsdjango-storages. Das Paketdjango-storagesbietet Django das Speicher-BackendS3Boto3Storage, das die Bibliothekboto3verwendet, um Dateien auf einen S3-kompatiblen Objektspeicherdienst hochzuladen.

Installieren Sie zunächst die Python-Pakete "django-storages" undboto3mitpip:

pip install django-storages boto3

Öffnen Sie als Nächstes die Django-Einstellungsdatei Ihrer App erneut:

nano ~/django-polls/mysite/settings.py

Navigieren Sie zum AbschnittINSTALLED_APPS der Datei und hängen Siestorages an die Liste der installierten Apps an:

~/django-polls/mysite/settings.py

. . .

INSTALLED_APPS = [
    . . .
    'django.contrib.staticfiles',
    'storages',
]

. . .

Scrollen Sie weiter unten in der Datei zu denSTATIC_URL, die wir zuvor geändert haben. Wir werden diese Werte jetzt überschreiben und die Backend-Parameter vonS3Boto3Storageanhängen. Löschen Sie den zuvor eingegebenen Code und fügen Sie die folgenden Blöcke hinzu, die Zugriffs- und Standortinformationen für Ihren Space enthalten. Denken Sie daran, die hier hervorgehobenen Werte durch Ihre eigenen Informationen zu ersetzen: ~/django-polls/mysite/settings.py

. . .

# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/2.1/howto/static-files/

AWS_ACCESS_KEY_ID = 'your_spaces_access_key'
AWS_SECRET_ACCESS_KEY = 'your_spaces_secret_key'

AWS_STORAGE_BUCKET_NAME = 'your_space_name'
AWS_S3_ENDPOINT_URL = 'spaces_endpoint_URL'
AWS_S3_OBJECT_PARAMETERS = {
    'CacheControl': 'max-age=86400',
}
AWS_LOCATION = 'static'
AWS_DEFAULT_ACL = 'public-read'

STATICFILES_STORAGE = 'storages.backends.s3boto3.S3Boto3Storage'

STATIC_URL = '{}/{}/'.format(AWS_S3_ENDPOINT_URL, AWS_LOCATION)
STATIC_ROOT = 'static/'

Wir definieren die folgenden Konfigurationselemente:

AWS_ACCESS_KEY_ID: Die Zugriffsschlüssel-ID für den Speicherplatz, die Sie in den Lernprogrammvoraussetzungen erstellt haben. Wenn Sie keinen Satz von Zugriffsschlüsseln erstellt haben, konsultieren SieSharing Access to Spaces with Access Keys.
AWS_SECRET_ACCESS_KEY: Der geheime Schlüssel für den DigitalOcean Space.
AWS_STORAGE_BUCKET_NAME: Ihr DigitalOcean Space-Name.
AWS_S3_ENDPOINT_URL: Die Endpunkt-URL, die für den Zugriff auf den Objektspeicherdienst verwendet wird. Für DigitalOcean ist dies abhängig von der Space-Region etwahttps://nyc3.digitaloceanspaces.com.
AWS_S3_OBJECT_PARAMETERS Legt die Cache-Steuerelement-Header für statische Dateien fest.
AWS_LOCATION: Definiert ein Verzeichnis im Objektspeicherbereich, in dem alle statischen Dateien abgelegt werden.
AWS_DEFAULT_ACL: Definiert die Zugriffssteuerungsliste (ACL) für die statischen Dateien. Wenn Siepublic-read festlegen, wird sichergestellt, dass die Dateien für Endbenutzer öffentlich zugänglich sind.
STATICFILES_STORAGE: Legt das Speicher-Backend fest, das Django zum Auslagern statischer Dateien verwendet. Dieses Backend sollte mit jedem S3-kompatiblen Backend funktionieren, einschließlich DigitalOcean Spaces.
STATIC_URL: Gibt die Basis-URL an, die Django beim Generieren von URLs für statische Dateien verwenden soll. Hier kombinieren wir die Endpunkt-URL und das Unterverzeichnis für statische Dateien, um eine Basis-URL für statische Dateien zu erstellen.
STATIC_ROOT: Gibt an, wo statische Dateien lokal erfasst werden sollen, bevor sie in den Objektspeicher kopiert werden.

Speichern und schließen Sie die Datei, wenn Sie mit der Bearbeitung fertig sind.

Wenn Sie von nun ancollectstatic ausführen, lädt Django die statischen Dateien Ihrer App in den Space hoch. Wenn Sie Django starten, werden statische Elemente wie CSS und Javascript in diesem Space bereitgestellt.

Im nächsten Abschnitt aktivieren wir das CDN für diesen Space und konfigurieren optional eine benutzerdefinierte Unterdomäne für das Spaces-CDN. Dies beschleunigt die Bereitstellung Ihrer statischen Django-Projektdateien, indem diese über ein geografisch verteiltes Netzwerk von Edgeservern abgerufen werden. Weitere Informationen zu CDNs finden Sie unterUsing a CDN to Speed Up Static Content Delivery. Wenn Sie Spaces CDN nicht aktivieren möchten, fahren Sie mitConfiguring CORS Headers fort.

CDN aktivieren (optional)

Um die Übermittlung statischer Dateien über das CDN von DigitalOcean Spaces zu aktivieren, aktivieren Sie zunächst das CDN für Ihren DigitalOcean Space. Informationen dazu finden Sie inHow to Enable the Spaces CDN in der DigitalOcean-Produktdokumentation.

Wenn Siecustom domain mit Spaces CDN verwenden möchten, erstellen Sie den CNAME-Eintrag der Subdomain und die entsprechenden SSL-Zertifikate, indem SieHow to Customize the Spaces CDN Endpoint with a Subdomain folgen.

Die Verwendung einer benutzerdefinierten Domain mit Spaces CDN wird dringend empfohlen. Dadurch wird die Suchmaschinenoptimierung (Search Engine Optimization, SEO) für Ihre Website drastisch verbessert, indem die URLs Ihrer ausgelagerten Inhalte den URLs Ihrer Django-Website ähneln. Um eine benutzerdefinierte Domain mit Spaces CDN zu verwenden, müssen Sie sicherstellen, dass Sie Ihre Domain zuerst Ihrem DigitalOcean-Konto hinzufügen. Um zu erfahren, wie das geht, konsultieren SieHow to Add Domains.

Nachdem Sie das CDN für Ihren Space aktiviert und optional eine benutzerdefinierte Subdomain dafür erstellt haben, navigieren Sie mitCloud Control Panel zu Ihrem Space. Unter Ihrem Space-Namen sollte ein neuerEndpoints-Link angezeigt werden:

List of Space Endpoints

Diese Endpunkte sollten Ihren Space-Namen enthalten. Wenn Sie eine benutzerdefinierte Subdomain für Spaces CDN erstellt haben, enthält diese Liste einen zusätzlichen Endpunkt namensSubdomain.

Der Endpunkt vonEdgeleitet Anforderungen für Spaces-Objekte durch das CDN und bedient sie so weit wie möglich aus dem Edge-Cache. Notieren Sie sich den Endpunkt vonEdge, da wir ihn zum Konfigurieren des Plugins vondjango-storagesverwenden werden. Wenn Sie eine Subdomain für Spaces CDN erstellt haben, ist der Endpunkt vonSubdomainein Alias für den Endpunkt vonEdge.

Bearbeiten Sie als Nächstes die Django-Einstellungsdatei Ihrer App erneut:

nano ~/django-polls/mysite/settings.py

Navigieren Sie zum Abschnitt Statische Dateien, den wir kürzlich geändert haben. Fügen Sie den ParameterAWS_S3_CUSTOM_DOMAIN hinzu, um den CDN-Endpunkt des Pluginsdjango-storageszu konfigurieren, und aktualisieren Sie den ParameterSTATIC_URL, um diesen neuen CDN-Endpunkt zu verwenden:

~/django-polls/mysite/settings.py

. . .

# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/2.1/howto/static-files/

# Moving static assets to DigitalOcean Spaces as per:
# https://www.digitalocean.com/community/tutorials/how-to-set-up-object-storage-with-django
AWS_ACCESS_KEY_ID = 'your_spaces_access_key'
AWS_SECRET_ACCESS_KEY = 'your_spaces_secret_key'

AWS_STORAGE_BUCKET_NAME = 'your_space_name'
AWS_S3_ENDPOINT_URL = 'spaces_endpoint_URL'
AWS_S3_CUSTOM_DOMAIN = 'spaces_edge_endpoint_URL'
AWS_S3_OBJECT_PARAMETERS = {
    'CacheControl': 'max-age=86400',
}
AWS_LOCATION = 'static'
AWS_DEFAULT_ACL = 'public-read'

STATICFILES_STORAGE = 'storages.backends.s3boto3.S3Boto3Storage'

STATIC_URL = '{}/{}/'.format(AWS_S3_CUSTOM_DOMAIN, AWS_LOCATION)
STATIC_ROOT = 'static/'

Ersetzen Sie hier diespaces_edge_endpoint_URL durch den Edge-Endpunkt, den Sie gerade notiert haben, und kürzen Sie das Präfixhttps://. Wenn die Edge-Endpunkt-URL beispielsweisehttps://example.sfo2.cdn.digitaloceanspaces.com lautet, sollteAWS_S3_CUSTOM_DOMAIN aufexample.sfo2.cdn.digitaloceanspaces.com festgelegt werden.

Wenn Sie eine benutzerdefinierte Subdomain erstellt haben, ersetzen Siespaces_edge_endpoint_URL durch den Endpunkt der benutzerdefinierten Subdomain, wobei Sie das Präfixhttps://abschneiden. Wenn die Subdomain-Endpunkt-URL beispielsweisehttps://assets.example.com lautet, sollteAWS_S3_CUSTOM_DOMAIN aufassets.example.com gesetzt werden.

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Wenn Sie Django starten, werden nun statische Inhalte mithilfe des CDN für Ihren DigitalOcean Space bereitgestellt.

Bevor wir testen, ob dies alles ordnungsgemäß funktioniert, müssen wir die Header vonCross-Origin Resource Sharing (CORS)für unsere Spaces-Dateien konfigurieren. Andernfalls kann Ihr Webbrowser den Zugriff auf bestimmte statische Assets verweigern. Wenn Sie eine benutzerdefinierte Subdomain mit Spaces CDN für dieselbe von Django verwendete Domain verwenden, können Sie mitTesting Spaces Static File Delivery fortfahren.

CORS-Header konfigurieren

CORS-Header teilen dem Webbrowser mit, dass eine Anwendung, die in einer Domäne ausgeführt wird, auf Skripts oder Ressourcen zugreifen kann, die sich in einer anderen Domäne befinden. In diesem Fall müssen wir für die Domain unseres Django-Servers die gemeinsame Nutzung ursprungsübergreifender Ressourcen zulassen, damit Anfragen nach statischen Dateien im Space vom Webbrowser nicht abgelehnt werden.

[.note] #Note: Dieser Schritt ist nur erforderlich, wenn Sienot verwenden und eine benutzerdefinierte Subdomain mit Spaces CDN verwenden.
#

Navigieren Sie zunächst über die Cloud-Systemsteuerung zur SeiteSettingsIhres Space:

Screenshot of the Settings tab

Klicken Sie im AbschnittCORS Configurations aufAdd.

CORS advanced settings

Geben Sie hier unterOrigin den Platzhalterursprung* ein

[.warning] #Warning: Wenn Sie Ihre App in der Produktion bereitstellen, müssen Sie diesen Wert in Ihre genaue Ursprungsdomäne ändern (einschließlich des Protokollshttp:// oderhttps://). Dies als Platzhalterursprung zu belassen ist unsicher, und wir tun dies hier nur zu Testzwecken, da das Setzen des Ursprungs aufhttp://example.com:8000 (unter Verwendung eines nicht standardmäßigen Ports) derzeit nicht unterstützt wird.
#

Wählen Sie unterAllowed MethodsGET aus.

Klicken Sie aufAdd Header und geben Sie in das angezeigte TextfeldAccess-Control-Allow-Origin ein.

Setzen SieAccess Control Max Age auf600, sodass der soeben erstellte Header alle 10 Minuten abläuft.

Klicken Sie aufSave Options.

Von nun an enthalten Objekte in Ihrem Space die entsprechenden Antwortheader vonAccess-Control-Allow-Origin, sodass moderne sichere Webbrowser diese Dateien domänenübergreifend abrufen können.

Testen von Spaces Static File Delivery

Wir werden jetzt testen, ob Django statische Dateien aus unserem DigitalOcean Space korrekt bereitstellt.

Navigiere zu deinem Django App-Verzeichnis:

cd ~/django-polls

Führen Sie von hier auscollectstatic aus, um statische Dateien zu sammeln und in Ihren DigitalOcean Space hochzuladen:

python manage.py collectstatic

Sie sollten die folgende Ausgabe sehen:

OutputYou have requested to collect static files at the destination
location as specified in your settings.

This will overwrite existing files!
Are you sure you want to do this?

Type 'yes' to continue, or 'no' to cancel:

Geben Sieyes ein und drücken Sie zur BestätigungENTER.

Sie sollten dann eine Ausgabe wie die folgende sehen

Output121 static files copied.

Dies bestätigt, dass Django die statischen Dateien derpolls-App erfolgreich in Ihren Space hochgeladen hat. Sie können mitCloud Control Panel zu Ihrem Space navigieren und die Dateien im Verzeichnisstatic überprüfen.

Als Nächstes überprüfen wir, ob Django die entsprechenden URLs neu schreibt.

Starten Sie den Gunicorn-Server:

gunicorn --bind 0.0.0.0:8000 mysite.wsgi

Besuchen Sie in Ihrem Webbrowser den Domainnamen oder die IP-Adresse Ihres Servers, gefolgt von:8000 und/admin:

http://server_domain_or_IP:8000/admin

Sie sollten wieder das Administrator-Authentifizierungsfenster der Polls-App sehen, diesmal mit korrektem Stil.

Verwenden Sie jetzt die Entwicklertools Ihres Browsers, um den Seiteninhalt zu überprüfen und die Speicherorte der Quelldatei anzuzeigen.

Klicken Sie dazu mit der rechten Maustaste auf die Seite und wählen SieInspect aus.

Sie sollten das folgende Fenster sehen:

Chrome Dev Tools Window

Klicken Sie hier in der Symbolleiste aufSources. In der Liste der Quelldateien im linken Bereich sollten/admin/login unter der Domäne Ihres Django-Servers undstatic/admin unter dem CDN-Endpunkt Ihres Space angezeigt werden. Innerhalb vonstatic/admin sollten sowohl die Verzeichnissecss als auchfonts angezeigt werden.

Hiermit wird bestätigt, dass CSS-Stylesheets und -Schriften korrekt vom CDN Ihres Space bereitgestellt werden.

Wenn Sie mit dem Testen fertig sind, drücken SieCTRL-C im Terminalfenster, um Gunicorn zu stoppen.

Sie können Ihre aktive virtuelle Python-Umgebung deaktivieren, indem Siedeactivate eingeben:

deactivate

Ihre Eingabeaufforderung sollte wieder normal sein.

Zu diesem Zeitpunkt haben Sie statische Dateien erfolgreich von Ihrem Django-Server entfernt und stellen sie aus dem Objektspeicher bereit. Jetzt können wir Gunicorn so konfigurieren, dass es automatisch als Systemdienst gestartet wird.

[[Schritt 8 - Erstellen von Systemd-Socket- und Servicedateien für Gunicorn] == Schritt 8 - Erstellen von Systemdocket- und Servicedateien für Gunicorn

InStep 6 haben wir getestet, dass Gunicorn mit unserer Django-Anwendung interagieren kann, aber wir sollten eine robustere Methode zum Starten und Stoppen des Anwendungsservers implementieren. Zu diesem Zweck erstellen wir System-Service- und Socket-Dateien.

Der Gunicorn-Socket wird beim Booten erstellt und wartet auf Verbindungen. Wenn eine Verbindung hergestellt wird, startet systemd automatisch den Gunicorn-Prozess, um die Verbindung herzustellen.

Erstellen und öffnen Sie zunächst eine systemd-Socket-Datei für Gunicorn mit den Berechtigungen vonsudo:

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

Im Inneren erstellen wir einen Abschnitt[Unit] zur Beschreibung des Sockets, einen Abschnitt[Socket] zur Definition der Socket-Position und einen Abschnitt[Install], um sicherzustellen, dass der Socket zum richtigen Zeitpunkt erstellt wird. Fügen Sie der Datei den folgenden Code hinzu:

/etc/systemd/system/gunicorn.socket

[Unit]
Description=gunicorn socket

[Socket]
ListenStream=/run/gunicorn.sock

[Install]
WantedBy=sockets.target

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Erstellen und öffnen Sie als Nächstes eine systemd-Servicedatei für Gunicorn mit den Berechtigungensudoin Ihrem Texteditor. Der Dienstdateiname sollte mit Ausnahme der Erweiterung mit dem Socketdateinamen übereinstimmen:

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

Beginnen Sie mit dem Abschnitt[Unit], in dem Metadaten und Abhängigkeiten angegeben sind. Wir werden hier eine Beschreibung unseres Dienstes einfügen und das init-System anweisen, diese erst zu starten, nachdem das Netzwerkziel erreicht wurde. Da unser Service auf dem Socket aus der Socket-Datei basiert, müssen wir eineRequires-Richtlinie einfügen, um diese Beziehung anzugeben:

/etc/systemd/system/gunicorn.service

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

Als Nächstes öffnen wir den Abschnitt[Service]. Wir geben den Benutzer und die Gruppe an, unter denen die Ausführung erfolgen soll. Wir geben unserem regulären Benutzerkonto den Besitz des Prozesses, da ihm alle relevanten Dateien gehören. Wir geben derwww-data-Gruppe Gruppenbesitz, damit Nginx problemlos mit Gunicorn kommunizieren kann.

Anschließend ordnen wir das Arbeitsverzeichnis zu und geben den Befehl zum Starten des Dienstes an. In diesem Fall müssen wir den vollständigen Pfad zur ausführbaren Datei von Gunicorn angeben, die in unserer virtuellen Umgebung installiert ist. Wir binden den Prozess an den Unix-Socket, den wir im Verzeichnis/runerstellt haben, damit der Prozess mit Nginx kommunizieren kann. Wir protokollieren alle Daten in der Standardausgabe, damit derjournald-Prozess die Gunicorn-Protokolle erfassen kann. Wir können hier auch optionale Gunicorn-Anpassungen festlegen, beispielsweise die Anzahl der Worker-Prozesse. Hier führen wir Gunicorn mit 3 Arbeitsprozessen aus.

Fügen Sie der Datei den folgenden Dienstabschnitt hinzu. Stellen Sie sicher, dass Sie den hier aufgeführten Benutzernamen durch Ihren eigenen Benutzernamen ersetzen:

/etc/systemd/system/gunicorn.service

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

[Service]
User=sammy
Group=www-data
WorkingDirectory=/home/sammy/django-polls
ExecStart=/home/sammy/envs/polls/bin/gunicorn \
          --access-logfile - \
          --workers 3 \
          --bind unix:/run/gunicorn.sock \
          mysite.wsgi:application

Schließlich fügen wir einen Abschnitt[Install]hinzu. Dies teilt systemd mit, mit was dieser Dienst verknüpft werden soll, wenn er beim Booten gestartet werden kann. Wir möchten, dass dieser Dienst gestartet wird, wenn das reguläre Mehrbenutzersystem ausgeführt wird:

/etc/systemd/system/gunicorn.service

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

[Service]
User=sammy
Group=www-data
WorkingDirectory=/home/sammy/django-polls
ExecStart=/home/sammy/envs/polls/bin/gunicorn \
          --access-logfile - \
          --workers 3 \
          --bind unix:/run/gunicorn.sock \
          mysite.wsgi:application

[Install]
WantedBy=multi-user.target

Damit ist unsere systemd-Servicedatei vollständig. Speichern und schließen Sie es jetzt.

Jetzt können wir den Gunicorn-Sockel starten und aktivieren. Dadurch wird die Socket-Datei jetzt und beim Booten bei/run/gunicorn.sock erstellt. Wenn eine Verbindung zu diesem Socket hergestellt wird, startet systemd automatisch diegunicorn.service, um dies zu verarbeiten:

sudo systemctl start gunicorn.socket
sudo systemctl enable gunicorn.socket

Wir können bestätigen, dass der Vorgang erfolgreich war, indem wir nach der Socket-Datei suchen.

Suchen nach der Gunicorn-Socket-Datei

Überprüfen Sie den Status des Prozesses, um festzustellen, ob er erfolgreich gestartet wurde:

sudo systemctl status gunicorn.socket

Sie sollten die folgende Ausgabe sehen:

OutputFailed to dump process list, ignoring: No such file or directory
● gunicorn.socket - gunicorn socket
   Loaded: loaded (/etc/systemd/system/gunicorn.socket; enabled; vendor preset: enabled)
   Active: active (running) since Tue 2019-03-05 19:19:16 UTC; 1h 22min ago
   Listen: /run/gunicorn.sock (Stream)
   CGroup: /system.slice/gunicorn.socket

Mar 05 19:19:16 django systemd[1]: Listening on gunicorn socket.

Überprüfen Sie als Nächstes, ob die Dateigunicorn.sockim Verzeichnis/runvorhanden ist:

file /run/gunicorn.sock

Output/run/gunicorn.sock: socket

Wenn der Befehlsystemctl status anzeigt, dass ein Fehler aufgetreten ist, oder wenn Sie die Dateigunicorn.sock nicht im Verzeichnis finden, ist dies ein Hinweis darauf, dass der Gunicorn-Socket nicht korrekt erstellt wurde. Überprüfen Sie die Protokolle des Gunicorn-Sockets, indem Sie Folgendes eingeben:

sudo journalctl -u gunicorn.socket

Sehen Sie sich die Datei/etc/systemd/system/gunicorn.socketnoch einmal an, um Probleme zu beheben, bevor Sie fortfahren.

Testen der Socket-Aktivierung

Wenn Sie nur die Einheitgunicorn.socketgestartet haben, istgunicorn.servicederzeit nicht aktiv, da der Socket noch keine Verbindungen erhalten hat. Sie können dies überprüfen, indem Sie Folgendes eingeben:

sudo systemctl status gunicorn

Output● gunicorn.service - gunicorn daemon
   Loaded: loaded (/etc/systemd/system/gunicorn.service; disabled; vendor preset: enabled)
   Active: inactive (dead)

Um den Socket-Aktivierungsmechanismus zu testen, können Sie eine Verbindung zum Socket übercurl senden, indem Sie Folgendes eingeben:

curl --unix-socket /run/gunicorn.sock localhost

Sie sollten die HTML-Ausgabe Ihrer Anwendung im Terminal sehen. Dies zeigt an, dass Gunicorn gestartet wurde und Ihre Django-Anwendung bedienen kann. Sie können überprüfen, ob der Gunicorn-Dienst ausgeführt wird, indem Sie Folgendes eingeben:

sudo systemctl status gunicorn

Output● gunicorn.service - gunicorn daemon
   Loaded: loaded (/etc/systemd/system/gunicorn.service; disabled; vendor preset: enabled)
   Active: active (running) since Tue 2019-03-05 20:43:56 UTC; 1s ago
 Main PID: 19074 (gunicorn)
    Tasks: 4 (limit: 4915)
   CGroup: /system.slice/gunicorn.service
           ├─19074 /home/sammy/envs/polls/bin/python3 /home/sammy/envs/polls/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock mysite.wsgi:application
           ├─19098 /home/sammy/envs/polls/bin/python3 /home/sammy/envs/polls/bin/gunicorn
. . .

Mar 05 20:43:56 django systemd[1]: Started gunicorn daemon.
Mar 05 20:43:56 django gunicorn[19074]: [2019-03-05 20:43:56 +0000] [19074] [INFO] Starting gunicorn 19.9.0
. . .
Mar 05 20:44:15 django gunicorn[19074]:  - - [05/Mar/2019:20:44:15 +0000] "GET / HTTP/1.1" 301 0 "-" "curl/7.58.0"

Wenn die Ausgabe voncurl oder die Ausgabe vonsystemctl status anzeigt, dass ein Problem aufgetreten ist, überprüfen Sie die Protokolle auf weitere Details:

sudo journalctl -u gunicorn

Sie können auch die Datei/etc/systemd/system/gunicorn.serviceauf Probleme überprüfen. Wenn Sie Änderungen an dieser Datei vornehmen, müssen Sie den Dämon neu laden, um die Service-Definition erneut zu lesen und den Gunicorn-Prozess neu zu starten:

sudo systemctl daemon-reload
sudo systemctl restart gunicorn

Stellen Sie sicher, dass Sie alle Probleme beheben, bevor Sie mit der Konfiguration des Nginx-Servers fortfahren.

[[Schritt 8 - Konfigurieren von Nginx-https-und-Gunicorn-Proxy-Passing]] == Schritt 8 - Konfigurieren von Nginx HTTPS- und Gunicorn-Proxy-Passing

Da Gunicorn nun stabiler eingerichtet ist, müssen wir Nginx so konfigurieren, dass Verbindungen verschlüsselt werden und der Datenverkehr an den Gunicorn-Prozess übergeben wird.

Wenn Sie die Voraussetzungen erfüllt und Nginx mit Let's Encrypt eingerichtet haben, sollte Ihnen bereits eine Serverblockdatei entsprechend Ihrer Domain im Verzeichnissites-availablevon Nginx zur Verfügung stehen. Wenn nicht, folgen SieHow To Secure Nginx with Let’s Encrypt on Ubuntu 18.04 und kehren Sie zu diesem Schritt zurück.

Bevor wir die Serverblockdatei vonexample.combearbeiten, entfernen wir zunächst die Serverblockdatei vondefault, die nach der Installation von Nginx standardmäßig eingeführt wird:

sudo rm /etc/nginx/sites-enabled/default

Wir ändern jetzt die Serverblockdatei vonexample.com, um den Datenverkehr an Gunicorn weiterzuleiten, anstatt die im Voraussetzungsschritt konfigurierte Standardseite vonindex.html.

Öffnen Sie die Ihrer Domain entsprechende Serverblockdatei in Ihrem Editor:

sudo nano /etc/nginx/sites-available/example.com

Sie sollten ungefähr Folgendes sehen:

/etc/nginx/sites-available/example.com

server {

        root /var/www/example.com/html;
        index index.html index.htm index.nginx-debian.html;

        server_name example.com www.example.com;

        location / {
                try_files $uri $uri/ =404;
        }

    listen [::]:443 ssl ipv6only=on; # managed by Certbot
    listen 443 ssl; # managed by Certbot
    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem; # managed by Certbot
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem; # managed by Certbot
    include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot

}

server {
    if ($host = example.com) {
        return 301 https://$host$request_uri;
    } # managed by Certbot


        listen 80;
        listen [::]:80;

        server_name example.com www.example.com;
    return 404; # managed by Certbot


}

Dies ist eine Kombination aus der inHow to Install Nginx on Ubuntu 18.04 erstellten Standard-Serverblockdatei und den von Let's Encrypt automatisch angehängten Ergänzungen. Wir werden den Inhalt dieser Datei löschen und eine neue Konfiguration schreiben, die den HTTP-Verkehr an HTTPS umleitet und eingehende Anforderungen an den Gunicorn-Socket weiterleitet, den wir im vorherigen Schritt erstellt haben.

Wenn Sie möchten, können Sie mitcp eine Sicherungskopie dieser Datei erstellen. Beenden Sie Ihren Texteditor und erstellen Sie ein Backup mit dem Namenexample.com.old:

sudo cp /etc/nginx/sites-available/example.com /etc/nginx/sites-available/example.com.old

Öffnen Sie nun die Datei erneut und löschen Sie ihren Inhalt. Wir werden die neue Konfiguration Block für Block erstellen.

Beginnen Sie mit dem Einfügen des folgenden Blocks, der HTTP-Anforderungen an Port80 an HTTPS umleitet:

/etc/nginx/sites-available/example.com

server {
    listen 80 default_server;
    listen [::]:80 default_server;
    server_name _;
    return 301 https://example.com$request_uri;
}

Hier warten wir auf HTTP-IPv4- und IPv6-Anforderungen an Port80 und senden einen 301-Antwortheader, um die Anforderung unter Verwendung derexample.com-Domäne an HTTPS-Port443 umzuleiten. Dadurch werden auch direkte HTTP-Anforderungen an die IP-Adresse des Servers umgeleitet.

Fügen Sie nach diesem Block den folgenden Block mit Konfigurationscode hinzu, der HTTPS-Anforderungen für die Domäneexample.comverarbeitet:

/etc/nginx/sites-available/example.com

. . .
server {
    listen [::]:443 ssl ipv6only=on;
    listen 443 ssl;
    server_name example.com www.example.com;

    # Let's Encrypt parameters
    ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
    include /etc/letsencrypt/options-ssl-nginx.conf;
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;

    location = /favicon.ico { access_log off; log_not_found off; }

    location / {
        proxy_pass         http://unix:/run/gunicorn.sock;
        proxy_redirect     off;

        proxy_set_header   Host              $http_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 https;
    }
}

Hier warten wir zuerst auf Port443 auf Anfragen, die die Domänenexample.com undwww.example.com treffen.

Als Nächstes stellen wir die gleiche Let's Encrypt-Konfiguration bereit, die in der Standard-Serverblockdatei enthalten ist. Diese Datei gibt den Speicherort des SSL-Zertifikats und des privaten Schlüssels sowie einige zusätzliche Sicherheitsparameter an.

Die Zeilelocation = /favicon.icoweist Nginx an, Probleme beim Auffinden eines Favicons zu ignorieren.

Der letztelocation = /-Block weist Nginx an, Anforderungen an den inStep 8 konfigurierten Gunicorn-Socket weiterzuleiten. Außerdem werden Header hinzugefügt, um den vorgelagerten Django-Server über die Weiterleitung einer Anforderung zu informieren und ihm verschiedene Anforderungseigenschaften bereitzustellen.

Nachdem Sie diese beiden Konfigurationsblöcke eingefügt haben, sollte die endgültige Datei ungefähr so aussehen:

/etc/nginx/sites-available/example.com

server {
    listen 80 default_server;
    listen [::]:80 default_server;
    server_name _;
    return 301 https://example.com$request_uri;
}
server {
        listen [::]:443 ssl ipv6only=on;
        listen 443 ssl;
        server_name example.com www.example.com;

        # Let's Encrypt parameters
        ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
        ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
        include /etc/letsencrypt/options-ssl-nginx.conf;
        ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;

        location = /favicon.ico { access_log off; log_not_found off; }

        location / {
          proxy_pass         http://unix:/run/gunicorn.sock;
          proxy_redirect     off;

          proxy_set_header   Host              $http_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 https;
        }
}

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Testen Sie Ihre Nginx-Konfiguration auf Syntaxfehler, indem Sie Folgendes eingeben:

sudo nginx -t

Wenn Ihre Konfiguration fehlerfrei ist, starten Sie Nginx neu, indem Sie Folgendes eingeben:

sudo systemctl restart nginx

Sie sollten nun in der Lage sein, die Domain oder IP-Adresse Ihres Servers zu besuchen, um Ihre Anwendung anzuzeigen. Ihr Browser sollte eine sichere HTTPS-Verbindung zum Django-Backend verwenden.

Um unser Django-Projekt vollständig zu sichern, müssen wir seinersettings.py-Datei einige Sicherheitsparameter hinzufügen. Öffnen Sie diese Datei erneut in Ihrem Editor:

nano ~/django-polls/mysite/settings.py

Scrollen Sie zum Ende der Datei und fügen Sie die folgenden Parameter hinzu:

~/django-polls/mysite/settings.py

. . .

SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
SECURE_SSL_REDIRECT = True

Diese Einstellungen teilen Django mit, dass Sie HTTPS auf Ihrem Server aktiviert haben, und weisen ihn an, "sichere" Cookies zu verwenden. Weitere Informationen zu diesen Einstellungen finden Sie unterSSL/HTTPS section vonSecurity in Django.

Speichern und schließen Sie die Datei, wenn Sie fertig sind.

Starten Sie schließlich Gunicorn neu:

sudo systemctl restart gunicorn

Zu diesem Zeitpunkt haben Sie Nginx so konfiguriert, dass HTTP-Anforderungen umgeleitet und an Gunicorn weitergeleitet werden. HTTPS sollte jetzt für Ihr Django-Projekt und Ihre Django-App vollständig aktiviert sein. Wenn Sie auf Fehler stoßen, kann diese Diskussion zutroubleshooting Nginx and Gunicorn hilfreich sein.

[.warning] #Warning: Wenn Sienot eine benutzerdefinierte Subdomain für Spaces CDN konfiguriert haben, wie inConfiguring CORS Headers angegeben, müssen SieOrigin vom Platzhalter* Domain zu Ihrem Domainnamen (https://example.com in diesem Handbuch), bevor Sie Ihre App für Endbenutzer zugänglich machen.
#

Fazit

In diesem Handbuch haben Sie eine skalierbare Django-Anwendung eingerichtet und konfiguriert, die auf einem Ubuntu 18.04-Server ausgeführt wird. Dieses Setup kann auf mehreren Servern repliziert werden, um eine hochverfügbare Architektur zu erstellen. Darüber hinaus können diese App und ihre Konfiguration mithilfe vonDocker oder einer anderen Container-Laufzeit containerisiert werden, um die Bereitstellung und Skalierung zu vereinfachen. Diese Container können dann in einem Containercluster wieKubernetes bereitgestellt werden. In einer kommenden Tutorial-Reihe werden wir untersuchen, wie die App dieses Djangopollscontainerisiert und modernisiert werden kann, damit sie in einem Kubernetes-Cluster ausgeführt werden kann.

Zusätzlich zu statischen Dateien möchten Sie möglicherweise auch Ihre Django Media-Dateien in den Objektspeicher verschieben. Um zu erfahren, wie das geht, konsultieren SieUsing Amazon S3 to Store your Django Site’s Static and Media Files. Sie können auch statische Dateien komprimieren, um deren Übermittlung an Endbenutzer weiter zu optimieren. Dazu können Sie ein Django-Plugin wieDjango compressor verwenden.

TOC

So richten Sie eine skalierbare Django-App mit von DigitalOcean verwalteten Datenbanken und Spaces ein

Einführung

Voraussetzungen

Testen der App mit dem Django Development Server

Testen der App mit Gunicorn

`django-storages` installieren und konfigurieren

CDN aktivieren (optional)

CORS-Header konfigurieren

Testen von Spaces Static File Delivery

Suchen nach der Gunicorn-Socket-Datei

Testen der Socket-Aktivierung

Fazit

Related

TOC

So richten Sie eine skalierbare Django-App mit von DigitalOcean verwalteten Datenbanken und Spaces ein

Einführung

Voraussetzungen

Testen der App mit dem Django Development Server

Testen der App mit Gunicorn

django-storages installieren und konfigurieren

CDN aktivieren (optional)

CORS-Header konfigurieren

Testen von Spaces Static File Delivery

Suchen nach der Gunicorn-Socket-Datei

Testen der Socket-Aktivierung

Fazit

Related

`django-storages` installieren und konfigurieren