So richten Sie die Django-Entwicklungsumgebung unter Ubuntu 18.04 ein

Django ist ein leistungsstarkes Web-Framework, mit dem Sie Ihre Python-Anwendung oder -Website auf den Weg bringen können. Django enthält einen vereinfachten Entwicklungsserver zum lokalen Testen Ihres Codes, aber für alles, was auch nur geringfügig mit der Produktion zu tun hat, ist ein sichererer und leistungsfähigerer Webserver erforderlich (Nginx - Apache).

In diesem Handbuch zeigen wir, wie einige Komponenten unter Ubuntu 18.04 installiert und konfiguriert werden, um Django-Anwendungen zu unterstützen und bereitzustellen. Wir werden eine PostgreSQL-Datenbank einrichten, anstatt die standardmäßige SQLite-Datenbank zu verwenden. Wir werden den Gunicorn-Anwendungsserver so konfigurieren, dass er eine Schnittstelle zu unseren Anwendungen bildet. Anschließend richten wir Nginx so ein, dass es einen Reverse-Proxy zu Gunicorn durchführt, wodurch wir Zugriff auf seine Sicherheits- und Leistungsfunktionen erhalten, um unsere Apps bereitzustellen.

Nicht-Root-Benutzer mit konfigurierten sudo-Berechtigungen erstellen

1. Anmeldung als root
2. Erstellen eines neuen Benutzers

   # adduser bobby

3. Gewähren von Administratorrechten
   Um diese Berechtigungen unserem neuen Benutzer hinzuzufügen, müssen wir den neuen Benutzer zur sudo-Gruppe hinzufügen. Standardmäßig dürfen unter Ubuntu 18.04 Benutzer, die der sudo-Gruppe angehören, den sudo-Befehl verwenden.

   # usermod -aG sudo bobby

Installieren Sie die Pakete aus den Ubuntu-Repositories

Um den Prozess zu beginnen, laden wir alle benötigten Elemente aus den Ubuntu-Repositories herunter und installieren sie. Wir werden den Python-Paketmanager pip verwenden, um etwas später zusätzliche Komponenten zu installieren.
Wir müssen den lokalen apt-Paketindex aktualisieren und dann die Pakete herunterladen und installieren. Die Pakete, die wir installieren, hängen davon ab, welche Python-Version Ihr Projekt verwenden wird.
Wenn Sie Django mit Python 3 installieren, geben Sie :

ein

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

Dadurch werden pip, die Python-Entwicklungsdateien, die zum späteren Erstellen von Gunicorn benötigt werden, das Postgres-Datenbanksystem und die für die Interaktion damit erforderlichen Bibliotheken sowie der Nginx-Webserver installiert.

Erstellen Sie die PostgreSQL-Datenbank und den Benutzer

Wir werden gleich loslegen und eine Datenbank und einen Datenbankbenutzer für unsere Django-Anwendung erstellen. Standardmäßig verwendet Postgres ein Authentifizierungsschema namens Peer-Authentifizierung für lokale Verbindungen. Im Grunde 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 namens postgres erstellt, der dem PostgreSQL-Administratorpostgres-Benutzer 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

Sie erhalten eine PostgreSQL-Eingabeaufforderung, in der wir unsere Anforderungen festlegen können.

Erstellen Sie zunächst eine Datenbank für Ihr Projekt

Postgres=# CREATE DATABASE newproject;

Hinweis: Jede Postgres-Anweisung muss mit einem Semikolon enden

Erstellen Sie als Nächstes einen Datenbankbenutzer für unser Projekt. Achten Sie darauf, ein sicheres Passwort zu wählen

Postgres=# CREATE USER newprojectuser WITH PASSWORD 'password';

Anschließend ändern wir einige der Verbindungsparameter für den gerade erstellten Benutzer. Dadurch werden Datenbankoperationen beschleunigt, sodass nicht bei jedem Verbindungsaufbau die richtigen Werte abgefragt und eingestellt werden müssen.

Wir setzen die Standardkodierung auf UTF-8, was Django erwartet. Wir setzen auch das standardmäßige Transaktionsisolationsschema auf Read Committed, wodurch Lesevorgänge von nicht festgeschriebenen Transaktionen blockiert werden. Zuletzt stellen wir die Zeitzone ein. Standardmäßig sind unsere Django-Projekte auf die Verwendung von UTC eingestellt. Dies sind alles Empfehlungen des Django-Projekts selbst.

Postgres=# ALTER ROLE newprojectuser SET client_encoding TO 'utf8';
Postgres=# ALTER ROLE newprojectuser SET default_transaction_isolation TO 'read committed';
Postgres=# ALTER ROLE newprojectuser SET timezone TO 'UTC';

Jetzt können wir unserem neuen Benutzer Zugriff geben, um unsere neue Datenbank zu verwalten

Postgres=# GRANT ALL PRIVILEGES ON DATABASE newproject TO newprojectuser;

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

Postgres=# \q

Erstellen Sie eine virtuelle Python 3-Umgebung für Ihr Projekt

Jetzt, da wir unsere Datenbank haben, können wir damit beginnen, den Rest unserer Projektanforderungen vorzubereiten. Wir werden unsere Python 3-Anforderungen zur einfacheren Verwaltung in einer virtuellen Umgebung installieren.

Dazu benötigen wir zunächst Zugriff auf den Befehl virtualenv. Wir können dies mit pip3 installieren.

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

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

Wenn virtualenv installiert ist, können wir mit der Erstellung unseres Projekts beginnen. Erstellen und verschieben Sie ein Verzeichnis, in dem wir unsere Projektdateien aufbewahren können:

  $ mkdir ~/djangoproject
  $ cd ~/djangoproject

Erstellen Sie im Projektverzeichnis eine virtuelle Python-Umgebung, indem Sie Folgendes eingeben:

$ virtualenv djangoprojectenv

Dadurch wird ein Verzeichnis namens djangoprojectenv erstellt innerhalb Ihres djangoproject Verzeichnis. Darin installiert es eine lokale Version von Python und eine lokale Version von Pip. Wir können dies verwenden, um eine isolierte Python-Umgebung für unser Projekt zu installieren und zu konfigurieren.

Bevor wir die Python-Anforderungen unseres Projekts installieren, müssen wir die virtuelle Umgebung aktivieren. Geben Sie dazu Folgendes ein:

$ source djangoproject/bin/activate

Ihre Eingabeaufforderung sollte sich ändern, um anzuzeigen, dass Sie jetzt in einer virtuellen Python-Umgebung arbeiten. Es sieht etwa so aus:(djangoprojectenv)user@host:~/djangoproject$ .
Installieren Sie bei aktiver virtueller Umgebung Django, Gunicorn und den PostgreSQL-Adapter psycopg2 mit der lokalen Instanz von pip:

Hinweis: Unabhängig davon, welche Version von Python 3 oder Python 2 Sie verwenden, sollten Sie bei aktivierter virtueller Umgebung den Befehl pip verwenden (nicht pip3).

(djangoprojectenv)$ pip install django gunicorn psycopg2-binary

Sie sollten jetzt über die gesamte Software verfügen, die zum Starten eines Django-Projekts erforderlich ist.

Erstellen und konfigurieren Sie ein neues Django-Projekt

Wenn unsere Python-Komponenten installiert sind, können wir die eigentlichen Django-Projektdateien erstellen.

Da wir bereits ein Projektverzeichnis haben, weisen wir Django an, die Dateien hier zu installieren. Es erstellt ein Verzeichnis der zweiten Ebene mit dem eigentlichen Code, was normal ist, und platziert ein Verwaltungsskript in diesem Verzeichnis. Der Schlüssel dazu ist, dass wir das Verzeichnis explizit definieren, anstatt Django zu erlauben, Entscheidungen in Bezug auf unser aktuelles Verzeichnis zu treffen:

(djangoprojectenv)$ django-admin.py startproject djangoproject ~/djangoproject

An dieser Stelle wird Ihr Projektverzeichnis (~/djangoproject in unserem Fall) sollte folgenden Inhalt haben:

• ~/djangoproject/manage.py :Ein Django-Projektmanagementskript.
• ~/djangoproject/myproject/ :Das Django-Projektpaket. Diese sollte die __init__.py enthalten , settings.py , urls.py und wsgi.py Dateien.
• ~/djangoproject/djangoprojectenv/ :Das Verzeichnis der virtuellen Umgebung, das wir zuvor erstellt haben.

Als erstes sollten wir mit unseren neu erstellten Projektdateien die Einstellungen anpassen. Öffnen Sie die Einstellungsdatei in Ihrem Texteditor:

(djangoprojectenv)$ nano ~/djangoproject/djangoproject/settings.py

Suchen Sie zunächst die Direktive ALLOWED_HOSTS. Dies definiert eine Liste der Serveradressen 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 festlegen, um eine bestimmte Klasse von Sicherheitslücken 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 aufgeführt werden, wobei die Einträge durch ein Komma getrennt sind. Wenn Sie Anfragen für eine ganze Domain und beliebige Subdomains wünschen, stellen Sie dem Anfang des Eintrags einen Punkt voran. Im folgenden Snippet finden Sie einige auskommentierte Beispiele, die zur Veranschaulichung verwendet werden.

~/djangoproject/djangoproject/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', '103.25.111.5']
ALLOWED_HOSTS = ['your_server_domain_or_IP', 'second_domain_or_IP', . . .]

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

Ändern Sie die Einstellungen mit Ihren PostgreSQL-Datenbankinformationen. Wir weisen Django an, den psycopg2adaptor zu verwenden, den wir mit pip installiert haben. Wir müssen den Datenbanknamen, den Datenbankbenutzernamen und das Kennwort des Datenbankbenutzers angeben und dann angeben, dass sich die Datenbank auf dem lokalen Computer befindet. Sie können die PORT-Einstellung als leeren String belassen:

~/djangoproject/djangoproject/settings.py
. . .
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'newproject',
        'USER': 'newprojectuser',
        'PASSWORD': 'password',
        'HOST': 'localhost',
        'PORT': '',
    }
}
. . .

Gehen Sie 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 Elemente bearbeiten kann. Die folgende Zeile weist Django an, sie in einem Verzeichnis namens static im Basisprojektverzeichnis abzulegen:

~/djangoproject/djangoproject/settings.py
. . .
STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'static/')

Speichern und schließen Sie mit Ctrl + x die Datei, wenn Sie fertig sind.
Jetzt können wir das anfängliche Datenbankschema mithilfe des Verwaltungsskripts in unsere PostgreSQL-Datenbank migrieren:

(djangoprojectenv)$ ~/djangoproject/manage.py makemigrations
(djangoprojectenv)$ ~/djangoproject/manage.py migrate

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

(djangoprojectenv)$ ~/djangoproject/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 an dem von uns konfigurierten Verzeichnisort sammeln, indem wir Folgendes eingeben:

(djangoprojectenv)$ ~/djangoproject/manage.py collectstatic

Sie müssen den Vorgang bestätigen. Die statischen Dateien werden dann in einem Verzeichnis namens static innerhalb Ihres Projektverzeichnisses abgelegt.

Wenn Sie die Anleitung zur Ersteinrichtung des Servers befolgt haben, sollten Sie über eine UFW-Firewall verfügen, die Ihren Server schützt. Um den Entwicklungsserver zu testen, müssen wir den Zugriff auf den verwendeten Port erlauben.

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

(djangoprojectenv)$ sudo ufw allow 8000

Schließlich können Sie Ihr Projekt testen, indem Sie den Django-Entwicklungsserver mit diesem Befehl starten:

(djangoprojectenv)$ ~/djangoproject/manage.py runserver 0.0.0.0:8000

Besuchen Sie in Ihrem Webbrowser den Domänennamen oder die IP-Adresse Ihres Servers, gefolgt von :8000:

http://server_domain_or_IP:8000

Sie sollten die standardmäßige Django-Indexseite für Django 2.0.7 sehen:

Wenn Sie http://server_domain_or_IP:8000/admin in die Adressleiste eingeben, werden Sie aufgefordert, den administrativen Benutzernamen und das Kennwort einzugeben, die Sie mit dem createsuperuser-Befehl erstellt haben:

Nach der Authentifizierung können Sie auf die standardmäßige Django-Administrationsschnittstelle zugreifen:

Wenn Sie mit der Erkundung fertig sind, drücken Sie CTRL-C im Terminalfenster, um den Entwicklungsserver herunterzufahren.

Testen der Fähigkeit von Gunicorn, dem Projekt zu dienen

Das Letzte, was wir tun wollen, bevor wir unsere virtuelle Umgebung verlassen, ist, Gunicorn zu testen, um sicherzustellen, dass es die Anwendung bedienen kann. Wir können dies tun, indem wir unser Projektverzeichnis eingeben und gunicorn verwenden, um das WSGI-Modul des Projekts zu laden:

(djangoprojectenv)$ cd ~/djangoproject
(djangoprojectenv)$ gunicorn --bind 0.0.0.0:8000 djangoproject.wsgi

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

Hinweis: Auf die Verwaltungsoberfläche wird kein Styling angewendet, da Gunicorn den dafür verantwortlichen statischen CSS-Inhalt nicht kennt.

Wir haben Gunicorn ein Modul übergeben, indem wir den relativen Verzeichnispfad zu Djangos wsgi.py-Datei angegeben haben, die der Einstiegspunkt zu unserer Anwendung ist, indem wir die Modulsyntax von Python verwendet haben. Innerhalb dieser Datei ist eine Funktion namens Anwendung definiert, die verwendet wird, um mit der Anwendung zu kommunizieren.

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

Wir sind jetzt mit der Konfiguration unserer Django-Anwendung fertig. Wir können unsere virtuelle Umgebung verlassen, indem wir Folgendes eingeben:

(myprojectenv)$ deactivate

Der Indikator für die virtuelle Umgebung in Ihrer Eingabeaufforderung wird entfernt.

Erstellen Sie eine Gunicorn-Systemdienstdatei

Wir haben getestet, dass Gunicorn mit unserer Django-Anwendung interagieren kann, aber wir sollten eine robustere Methode zum Starten und Stoppen des Anwendungsservers implementieren. Um dies zu erreichen, erstellen wir eine systemd-Dienstdatei.

Erstellen und öffnen Sie eine systemd-Dienstdatei für Gunicorn mit sudo-Berechtigungen in Ihrem Texteditor:

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

Beginnen Sie mit [Unit] -Abschnitt, der verwendet wird, um Metadaten und Abhängigkeiten anzugeben. Wir werden hier eine Beschreibung unseres Dienstes einfügen und dem Init-System mitteilen, dass es diesen erst starten soll, nachdem das Netzwerkziel erreicht wurde.

Als nächstes öffnen wir den [Service] Sektion. Wir geben den Benutzer und die Gruppe an, unter denen wir verarbeiten möchten. Wir werden unserem regulären Benutzerkonto das Eigentum an dem Prozess übertragen, da es alle relevanten Dateien besitzt. Wir geben www-data den Gruppenbesitz Gruppe, damit Nginx problemlos mit Gunicorn kommunizieren kann.

Wir ordnen dann das Arbeitsverzeichnis zu und geben den Befehl an, der zum Starten des Dienstes verwendet werden soll. In diesem Fall müssen wir den vollständigen Pfad zur ausführbaren Gunicorn-Datei angeben, die in unserer virtuellen Umgebung installiert ist. Wir werden es an einen Unix-Socket im Projektverzeichnis binden, da Nginx auf demselben Computer installiert ist. Dies ist sicherer und schneller als die Verwendung eines Netzwerkanschlusses. Wir können hier auch optionale Gunicorn-Anpassungen angeben. Zum Beispiel haben wir in diesem Fall 3 Worker-Prozesse angegeben.

Schließlich fügen wir einen [Install] hinzu Sektion. Dadurch wird systemd mitgeteilt, womit dieser Dienst verknüpft werden soll, wenn wir ihn zum Starten beim Booten aktivieren. Wir möchten, dass dieser Dienst gestartet wird, wenn das reguläre Mehrbenutzersystem eingerichtet ist und läuft:

/etc/systemd/system/gunicorn.service
[Unit]
Description=gunicorn daemon
After=network.target

[Service]
User=bobby
Group=www-data
WorkingDirectory=/home/bobby/djangoproject
ExecStart=/home/bobby/djangoproject/djangoproject/bin/gunicorn --access-logfile - --workers 3 --bind unix:/home/bobby/djangoproject/djangoproject.sock djangoproject.wsgi:application

[Install]
WantedBy=multi-user.target

Damit ist unsere systemd-Servicedatei vollständig. Jetzt speichern und schließen.

Wir sollten den Bobby-Benutzer zur www-data-Gruppe hinzufügen:

$ sudo usermod –a –G www-data bobby

Wir können jetzt den von uns erstellten Gunicorn-Dienst starten und ihn so aktivieren, dass er beim Booten startet:

$ sudo systemctl start gunicorn
$ sudo systemctl enable gunicorn

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

Überprüfen Sie den Status des Prozesses, um herauszufinden, ob er gestartet werden konnte:

$ sudo systemctl status gunicorn

Überprüfen Sie als Nächstes, ob djangoproject.sock vorhanden ist Datei in Ihrem Projektverzeichnis:

$ ls /home/bobby/djangoproject
Output
manage.py  djangoproject  djangoprojectenv  djangoproject.sock  static

Wenn der Befehl systemctl status anzeigt, dass ein Fehler aufgetreten ist, oder wenn Sie djangoproject.sock nicht finden Datei im Verzeichnis, ist dies ein Hinweis darauf, dass Gunicorn nicht korrekt gestartet werden konnte. Überprüfen Sie die Gunicorn-Prozessprotokolle, indem Sie Folgendes eingeben:

$ sudo journalctl -u gunicorn

Sehen Sie sich die Meldungen in den Protokollen an, um herauszufinden, wo Gunicorn auf Probleme gestoßen ist. Es gibt viele Gründe, warum Sie möglicherweise auf Probleme gestoßen sind, aber wenn Gunicorn die Socket-Datei nicht erstellen konnte, hat dies häufig einen der folgenden Gründe:

• Die Projektdateien gehören dem Root-Benutzer und nicht einem sudo-Benutzer
• Das WorkingDirectory Pfad innerhalb von /etc/systemd/system/gunicorn.service Datei zeigt nicht auf das Projektverzeichnis
• Die Konfigurationsoptionen, die dem Gunicorn-Prozess in ExecStart gegeben werden Richtlinie sind nicht korrekt. Überprüfen Sie die folgenden Elemente:
  • Der Pfad zur Gunicorn-Binärdatei zeigt auf den tatsächlichen Speicherort der Binärdatei innerhalb der virtuellen Umgebung
  • Der --bind Direktive definiert eine Datei, die in einem Verzeichnis erstellt werden soll, auf das Gunicorn zugreifen kann
  • Die djangoproject.wsgi:application ist ein genauer Pfad zum aufrufbaren WSGI. Das bedeutet, dass Sie, wenn Sie sich im WorkingDirectory befinden, in der Lage sein sollten, die aufrufbare benannte Anwendung zu erreichen, indem Sie in djangoproject.wsgi nachsehen Modul (was in eine Datei namens ./djangoproject/wsgi.py übersetzt wird )

Wenn Sie Änderungen an der Datei /etc/systemd/system/gunicorn.service vornehmen, laden Sie den Daemon neu, um die Dienstdefinition erneut zu lesen, und starten Sie den Gunicorn-Prozess neu, indem Sie Folgendes eingeben:

$ sudo systemctl daemon-reload
$ sudo systemctl restart gunicorn

Stellen Sie sicher, dass Sie eines der oben genannten Probleme beheben, bevor Sie fortfahren.

Konfiguriere Nginx für Proxy-Pass an Gunicorn

Nachdem Gunicorn eingerichtet ist, müssen wir Nginx so konfigurieren, dass der Datenverkehr an den Prozess weitergeleitet wird. Beginnen Sie mit dem Erstellen und Öffnen eines neuen Serverblocks im Sites-Available-Verzeichnis von Nginx:

$ sudo nano /etc/nginx/sites-available/djangoproject

Öffnen Sie im Inneren einen neuen Serverblock. Wir beginnen mit der Angabe, dass dieser Block auf dem normalen Port 80 lauschen und auf den Domainnamen oder die IP-Adresse unseres Servers antworten soll.

Als Nächstes weisen wir Nginx an, alle Probleme beim Auffinden eines Favicons zu ignorieren. Wir werden ihm auch mitteilen, wo die statischen Assets zu finden sind, die wir in unserem ~/djangoproject/static gesammelt haben Verzeichnis. Alle diese Dateien haben ein Standard-URI-Präfix von "/static" , damit wir einen Standortblock erstellen können, der diesen Anfragen entspricht.

Abschließend erstellen wir einen Standort-/{}-Block, der allen anderen Anfragen entspricht. Innerhalb dieses Speicherorts fügen wir die standardmäßigen proxy_params ein Datei, die in der Nginx-Installation enthalten ist, und dann leiten wir den Datenverkehr an den Socket weiter, den unser Gunicorn-Prozess erstellt hat:

/etc/nginx/sites-available/djangoproject
server {
    listen 80;
    server_name server_domain_or_IP;

    location = /favicon.ico { access_log off; log_not_found off; }
    location /static/ {
        root /home/bobby/djangoproject;
    }
    location / {
        include proxy_params;
        proxy_pass http://unix:/home/bobby/djangoproject/djangoproject.sock;
    }
}

Speichern und schließen Sie die Datei, wenn Sie fertig sind. Jetzt können wir die Datei aktivieren, indem wir sie mit sites-enabled verknüpfen Verzeichnis:

$ sudo ln -s /etc/nginx/sites-available/djangoproject /etc/nginx/sites-enabled

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

$ sudo nginx -t

Wenn keine Fehler gemeldet werden, fahren Sie fort und starten Sie Nginx neu, indem Sie Folgendes eingeben:

$ sudo systemctl restart nginx

Schließlich müssen wir unsere Firewall für normalen Datenverkehr auf Port 80 öffnen. Da wir keinen Zugriff mehr auf den Entwicklungsserver benötigen, können wir auch die Regel zum Öffnen von Port 8000 entfernen:

$ sudo ufw delete allow 8000
$ sudo ufw allow 'Nginx Full'

Sie sollten jetzt zur Domain oder IP-Adresse Ihres Servers gehen können, um Ihre Anwendung anzuzeigen.

Lesen Sie auch

• So richten Sie die UFW-Firewall unter Ubuntu 18.04 ein
• So installieren Sie LAMP Stack auf Ubuntu 18.04

Hinweis:Nach der Konfiguration von Nginx sollte der nächste Schritt darin bestehen, den Datenverkehr zum Server mit SSL/TLS zu sichern. Dies ist wichtig, da sonst alle Informationen, einschließlich Kennwörter, im Klartext über das Netzwerk gesendet werden.