Website-Suche

Wie man Python WSGI-Anwendungen mit dem Gunicorn-HTTP-Server hinter Nginx bereitstellt

Einführung

Vielleicht war es der Artikel über den Vergleich von Python-Web-Servern, der dich dazu verleitet hat, zu wechseln, oder die Tatsache, dass du einfach dein aktuelles Deployment-Stack für Anwendungen übertroffen hast. Du bist daran interessiert, mehr über den Gunicorn-Web-Server zu erfahren und möchtest lernen, wie man eine Python-Anwendung gründlich von Anfang an bereitstellt.

In diesem DigitalOcean-Artikel ist es unser Ziel, Ihnen bei all dem und noch mehr zu helfen. Wir werden mit der Erweiterung unseres Wissens über den ausgezeichneten Gunicorn WSGI HTTP-Server beginnen und mit der Bereitstellung von Python WSGI-Webanwendungen fortfahren, die auf verschiedenen populären Frameworks basieren.

Glossar

1. Über Gunicorn und Nginx

  1. Gunicorn
  2. Webanwendungsbereitstellung mit Nginx

2. Vorbereitung Ihres Droplets für die Produktion

  1. Aktualisierung des Standardbetriebssystems
  2. Einrichten von Python, pip und virtualenv
  3. Erstellen einer virtuellen (Python) Umgebung
  4. Herunterladen und Installieren von Gunicorn
  5. Herunterladen und Installieren von Nginx

3. Bereitstellung von Python-Webanwendungen mit Gunicorn

  1. WSGI
  2. WSGI-Anwendungsobjekt (aufrufbar): wsgi.py
  3. Den Server betreiben
  4. Konfiguration und Optimierung von Gunicorn
  5. Nginx konfigurieren
  6. Verschiedene Tipps und Vorschläge

Über Gunicorn und Nginx

Gunicorn

Gunicorn ist ein eigenständiger WSGI-Webanwendungsserver, der viele Funktionen bietet. Er unterstützt nativ verschiedene Frameworks mit seinen Adaptern und ist somit ein extrem einfach zu verwendender Ersatz für viele Entwicklungsserver, die während der Entwicklung eingesetzt werden.

Technisch gesehen funktioniert Gunicorn sehr ähnlich wie der erfolgreiche Unicorn-Webserver für Ruby-Anwendungen. Beide verwenden das, was als Pre-Fork-Modell bezeichnet wird. Das bedeutet im Wesentlichen, dass der zentrale [Gunicorn] Master-Prozess für die Verwaltung der Worker, die Erstellung von Sockets und Bindungen usw. zuständig ist.

Gunicorn Server Höhepunkte

  • Führt jede WSGI-Python-Webanwendung (und Framework) aus.

  • Kann als Ersatz für Paster (Pyramid), Djangos Entwicklungsserver, web2py usw. verwendet werden.

  • Kommt mit verschiedenen Arbeitertypen und Konfigurationen

  • Verwaltet Mitarbeiterprozesse automatisch

  • Unterstützung von HTTP/1.0 und HTTP/1.1 (Keep-Alive) durch synchrone und asynchrone Worker

  • Unterstützt SSL

  • Erweiterbar mit Hooks

  • Python 2.6+ und 3.x Unterstützung

Webanwendungsbereitstellung mit Nginx

Nginx ist ein sehr leistungsstarker Webserver/(Reverse-)Proxy. Seine aktuelle Popularität hat es aufgrund seiner Leichtgewichtigkeit, der relativ einfachen Handhabung und der einfachen Erweiterbarkeit (mit Add-Ons/Plugins) erreicht. Dank seiner Architektur ist es in der Lage, viele Anfragen (virtually unbegrenzt) zu verarbeiten, was - je nach Last Ihrer Anwendung oder Website - mit einigen anderen, älteren Alternativen wirklich schwer zu bewältigen sein könnte.

Erinnere dich: “Die Handhabung” von Verbindungen bedeutet technisch, dass man sie nicht abbricht und in der Lage ist, sie mit etwas zu bedienen. Du benötigst weiterhin, dass deine Anwendung und Datenbank gut funktionieren, damit Nginx Antworten an Clients bereitstellen kann, die keine Fehlermeldungen sind.

Warum Nginx als Reverse-Proxy vor einem Anwendungsserver verwenden?

Viele Frameworks und Anwendungsserver (einschließlich Gunicorn) können statische Dateien (z. B. Javascript, CSS, Bilder usw.) zusammen mit Antworten ausliefern. Es ist jedoch besser, einen (Reverse-Proxy-)Server wie Nginx mit der Aufgabe zu betrauen, diese Dateien bereitzustellen und die Verbindungen (Anfragen) zu verwalten. Dies entlastet die Anwendungsserver erheblich und sorgt für eine viel bessere Gesamtleistung.

Wenn Ihre Anwendung wächst, möchten Sie sie optimieren – und wenn die Zeit kommt, sie auf Server (VPS) zu verteilen, um mehr Verbindungen gleichzeitig verarbeiten zu können (und eine im Allgemeinen robustere Architektur zu haben). Einen Reverse-Proxy vor Ihren Anwendungsserver(n) zu haben, hilft Ihnen dabei von Anfang an.

Die Erweiterbarkeit von Nginx (z. B. natives Caching zusammen mit Failover und anderen Mechanismen) ist ebenfalls eine große Errungenschaft, die Webanwendungen im Gegensatz zu (einfacheren) Anwendungsservern zugutekommt.

Beispiel einer grundlegenden Serverarchitektur:

Client Request ----> Nginx (Reverse-Proxy)
                        |
                       /|\                           
                      | | `-> App. Server I.   127.0.0.1:8081
                      |  `--> App. Server II.  127.0.0.1:8082
                       `----> App. Server III. 127.0.0.1:8083

Hinweis: Bitte siehe den Abschnitt Konfigurieren und Optimieren von Gunicorn, um mehr über die Anzahl der zu verwendenden Server/Worker zu erfahren.

Vorbereitung Ihres Droplets für die Produktion

In diesem Abschnitt werden wir unsere virtuelle Umgebung für die Produktion vorbereiten (d.h. für die Bereitstellung unserer Anwendung).

Wir werden beginnen mit:

  • Das Aktualisieren des Standardbetriebssystems

  • Herunterladen und Installieren gängiger Python-Tools (d.h. pip, virtualenv)

  • eine virtuelle Umgebung erstellen, um die Anwendung zu enthalten (in der sich ihre Abhängigkeiten wie Gunicorn befinden)

Hinweis: Die hier gegebenen Anweisungen sind kurz gehalten. Um mehr zu erfahren, lesen Sie unseren Artikel über die Verwendung von pip und virtualenv: Gewöhnliche Python-Tools: Verwendung von virtualenv, Installation mit Pip und Verwaltung von Paketen.

Aktualisierung des Standardbetriebssystems

Hinweis: Wir werden die folgenden Setup- und Vorbereitungsmaßnahmen auf einem neuen Droplet durchführen, indem wir aktuelle Versionen von Betriebssystemen verwenden. Theoretisch sollten Sie keine Probleme haben, sie auf Ihrem VPS auszuprobieren. Wenn Sie jedoch bereits aktiv damit arbeiten, empfehlen wir dringend, auf ein neues System umzusteigen.

Um sicherzustellen, dass wir die neuesten verfügbaren Versionen der Standardanwendungen haben, müssen wir unser System aktualisieren.

Für Debian-basierte Systeme (d.h. Ubuntu, Debian) führen Sie Folgendes aus:

aptitude    update
aptitude -y upgrade

Für RHEL-basierte Systeme (d.h. CentOS) führen Sie Folgendes aus:

yum -y update

Einrichten von Python, pip und virtualenv

Hinweis für CentOS/RHEL-Benutzer:

CentOS/RHEL kommt standardmäßig als ein sehr schlanker Server. Sein Toolset, das wahrscheinlich veraltet für Ihre Bedürfnisse ist, ist nicht da, um Ihre Anwendungen auszuführen, sondern um die Systemwerkzeuge des Servers zu betreiben (z. B. YUM).

Um Ihr CentOS-System vorzubereiten, muss Python eingerichtet werden (d.h. aus dem Quellcode kompiliert) und pip/virtualenv müssen mit diesem Interpreter installiert werden.

Um mehr über Wie man Python 2.7.6 und 3.3.3 auf CentOS 6.4 und 5.8 einrichtet, einschließlich pip und virtualenv, zu erfahren, beziehen Sie sich bitte auf: Wie man Python 2.7.6 und 3.3.3 auf CentOS einrichtet.

Unter Ubuntu und Debian kommt eine aktuelle Version des Python-Interpreters standardmäßig. Das lässt uns nur eine begrenzte Anzahl zusätzlicher Pakete, die wir installieren müssen:

  • python-dev (Entwicklungstools),
  • pip (um Pakete zu verwalten),
  • virtualenv (um isolierte, virtuelle Umgebungen zu erstellen).

python-dev:

python-dev ist ein betriebssystemweites Paket, das erweiterte Entwicklertools zum Erstellen von Python-Modulen enthält.

Führen Sie den folgenden Befehl aus, um python-dev mit aptitude zu installieren:

aptitude install python-dev

pip:

pip ist ein Paketmanager, der uns hilft, die benötigten Anwendungsprogramme zu installieren.

Führen Sie die folgenden Befehle aus, um pip zu installieren:

curl https://bitbucket.org/pypa/setuptools/raw/bootstrap/ez_setup.py | python -
curl https://raw.github.com/pypa/pip/master/contrib/get-pip.py | python -
export PATH="/usr/local/bin:$PATH"

Möglicherweise benötigen Sie sudo-Rechte.

virtuelle Umgebung:

Es ist am besten, eine Python-Anwendung innerhalb ihrer eigenen Umgebung zusammen mit all ihren Abhängigkeiten zu isolieren. Eine Umgebung kann am besten (einfach gesagt) als ein isolierter Ort (ein Verzeichnis) beschrieben werden, in dem alles reside. Zu diesem Zweck wird ein Werkzeug namens virtualenv verwendet.

Führen Sie Folgendes aus, um virtualenv mit pip zu installieren:

sudo pip install virtualenv

Erstellen einer eigenständigen virtuellen (Python) Umgebung

Mit allen notwendigen Werkzeugen bereit können wir eine Umgebung schaffen, um unsere Anwendung bereitzustellen.

Denken Sie daran: Wenn Sie auf Ihrem Entwicklungsrechner (lokal) für Ihr Projekt keine virtuelle Umgebung haben, sollten Sie in Betracht ziehen, eine zu erstellen und Ihre Anwendung (sowie ihre Abhängigkeiten) dorthin zu verschieben.

Lassen Sie uns mit der Erstellung eines Ordners beginnen, der sowohl die virtuelle Umgebung als auch Ihr Anwendungsmodul enthält:

Sie können hier jeden Namen verwenden, der Ihren Bedürfnissen entspricht.

mkdir my_app

Wir können fortfahren, indem wir diesen Ordner betreten und eine neue virtuelle Umgebung darin erstellen:

Sie können auch einen beliebigen Namen für Ihre virtuelle Umgebung wählen.

cd my_app
virtualenv my_app_venv

Lass uns dort einen neuen Ordner erstellen, um dein Python-Anwendungsmodul ebenfalls zu enthalten:

Dies ist der Ordner, in dem Ihr Anwendungsmodul gespeichert wird.

mkdir app

Und aktiviere den Interpreter innerhalb der virtuellen Umgebung, um ihn zu verwenden:

Bitte stellen Sie sicher, dass Sie den Namen verwenden, den Sie für Ihre virtuelle Umgebung gewählt haben, falls Sie sich für etwas anderes als „my_app_venv“ entschieden haben.

source my_app_venv/bin/activate

Am Ende sollte Ihr Hauptanwendungsbereitstellungsverzeichnis folgendermaßen aussehen:

my_app              # Main Folder to Contain Everything Together
  |
  |=== my_app_venv  # V. Env. folder with the Python Int.
  |=== app          # Your application module
  |..
  |.

Herunterladen und Installieren von Gunicorn

Es ist immer die empfohlene Vorgehensweise, alle anwendungsbezogenen Elemente, soweit wie möglich, zusammen innerhalb der virtuellen Umgebung zu bündeln. Daher werden wir Gunicorn dort herunterladen und installieren.

Wenn Sie nicht in einer Umgebung arbeiten, wird Gunicorn global installiert (d.h. systemweit verfügbar). Dies wird nicht empfohlen. Wählen Sie immer die Verwendung von virtualenv.

Um Gunicorn mit pip zu installieren, führen Sie Folgendes aus:

pip install gunicorn

Herunterladen und Installieren von Nginx

Hinweis für CentOS/RHEL-Benutzer:

Die folgenden Anweisungen funktionieren nicht auf CentOS-Systemen. Bitte siehe dir die Anweisungen hier für CentOS an.

Führen Sie den folgenden Befehl aus, um den Standard-System-Paketmanager aptitude zu verwenden, um Nginx zu installieren:

sudo aptitude install nginx

Um Nginx auszuführen, können Sie Folgendes verwenden:

sudo service nginx start

Um Nginx zu stoppen, können Sie Folgendes verwenden:

sudo service nginx stop

Um Nginx neu zu starten, können Sie Folgendes verwenden:

Nach jeder Konfiguration von Nginx ist ein Neustart oder ein Reload erforderlich, damit die neuen Einstellungen wirksam werden.

sudo service nginx restart

Hinweis: Um mehr über Nginx auf Ubuntu zu erfahren, lesen Sie bitte unseren Artikel: So installieren Sie Nginx auf Ubuntu 12.04.

Python-Webanwendungen mit Gunicorn bereitstellen

In diesem Abschnitt werden wir sehen, wie eine WSGI-Anwendung mit Gunicorn funktioniert. Dieser Prozess besteht darin, dem Server ein WSGI-Anwendungsaufruf (z. B. application=(..)) als Einstiegspunkt bereitzustellen.

WSGI

WSGI ist kurz gesagt eine Schnittstelle zwischen einem Webserver und der Anwendung selbst. Sie existiert, um einen standardisierten Weg zwischen verschiedenen Servern und Anwendungen (Frameworks) zu gewährleisten, um miteinander zu arbeiten, was eine Austauschbarkeit ermöglicht, wenn notwendig (z. B. der Wechsel von der Entwicklungs- zur Produktionsumgebung), was heutzutage eine Notwendigkeit ist.

Hinweis: Wenn Sie mehr über WSGI und Python-Webserver erfahren möchten, lesen Sie unseren Artikel: Ein Vergleich von Webservern für auf Python basierende Webanwendungen.

WSGI-Anwendungsobjekt (aufrufbar): wsgi.py

Wie oben erwähnt, benötigen Webserver, die auf WSGI basieren, ein Anwendungsobjekt (d.h. das Ihrer Anwendung).

Bei den meisten Frameworks und Anwendungen besteht dies aus:

  • Eine wsgi.py, die ein Anwendungsobjekt (oder aufrufbares Objekt) enthält und bereitstellt, das vom Server verwendet werden kann.

Wir werden mit der Erstellung einer beispielhaften wsgi.py beginnen, die wir mit Gunicorn verwenden werden.

Sie können jeden Namen anstelle von „wsgi.py“ wählen. Dies sind jedoch die Namen, die üblicherweise verwendet werden (z. B. von Django).

Lassen Sie uns mit der Erstellung einer wsgi.py-Datei beginnen, um eine grundlegende WSGI-Anwendung zu enthalten.

Führen Sie den folgenden Befehl aus, um eine wsgi.py mit dem Texteditor nano zu erstellen:

nano wsgi.py

Lass uns fortfahren mit dem Verschieben (Kopieren/Einfügen) des grundlegenden WSGI-Anwendungscodes (der durch den Callable deiner eigenen Anwendung für die Produktion ersetzt werden sollte):

def application(env, start_response):
    start_response('200 OK', [('Content-Type', 'text/html')])
    return ["Hello!"]

Dies ist die Datei, die vom Server eingebunden wird, und jedes Mal, wenn eine Anfrage kommt, verwendet der Server diesen anwendbaren Aufruf, um die Anforderungsbehandler der Anwendung (z. B. Controller) auszuführen, nachdem die URL geparst wurde (z. B. mysite.tld/controller/method/variable).

Nachdem Sie den Anwendungscode eingefügt haben, drücken Sie CTRL+X und bestätigen Sie dann mit Y, um diese Datei im Ordner "my_app" neben der virtuellen Umgebung und dem App-Modul, das Ihre eigentliche Anwendung enthält, zu speichern.

Hinweis: Diese WSGI-Anwendung ist das grundlegendste Beispiel ihrer Art. Sie müssen diesen Codeblock ersetzen, um Ihr eigenes Anwendungsobjekt aus dem Anwendungsmodul einzufügen.

Sobald wir fertig sind, sollte Ihr Hauptanwendungsbereitstellungsverzeichnis so aussehen:

my_app              # Main Folder to Contain Everything Together
  |
  |=== my_app_venv  # V. Env. folder with the Python Int.
  |=== app          # Your application module
  |
  |--- wsgi.py      # File containing application callable
  |..
  |.

Den Server betreiben

Um Ihre Anwendung zu starten, müssen Sie nur folgende Befehle ausführen:

gunicorn [option] [option] .. [wsgi file]

Führen Sie Folgendes aus, um den Server zu starten:

gunicorn -b 0.0.0.0:8080 wsgi

Dies wird den Server im Vordergrund ausführen. Wenn Sie ihn stoppen möchten, drücken Sie CTRL+C.

Um den Server im Hintergrund auszuführen, führen Sie Folgendes aus:

gunicorn -b 0.0.0.0:8080 wsgi &

Wenn Sie eine Anwendung im Hintergrund ausführen, müssen Sie einen Prozessmanager (z. B. htop) verwenden, um sie zu beenden (oder anzuhalten).

Konfiguration und Optimierung von Gunicorn

Hinweis: Im Folgenden sind einige der am häufigsten verwendeten Konfigurations- und Optimierungseinstellungen aufgeführt. Um alle verfügbaren Optionen zu sehen, schauen Sie sich die offizielle Dokumentation zum Gunicorn-Konfigurationsüberblick an.

Wie bereits erwähnt, ist Gunicorn hochgradig konfigurierbar und es ist sehr einfach, alle erforderlichen Parameter nach Ihren Wünschen anzupassen.

[!] Wichtig: Alle unten aufgeführten Einstellungen und Konfigurationsoptionen sind zu verketten (einander nachfolgend), um gunicorn zu starten und Ihre Anwendung bereitzustellen. Sie können keine der Optionen nach dem Starten des Servers ändern. Welche Option oder Optionen Sie auch verwenden, sie müssen gefolgt werden von der wsgi-Datei, die den Einstiegspunkt zu Ihrer Anwendung enthält.

Beispiel:

Simply running the server (as shown above):
gunicorn -b 0.0.0.0:8080 wsgi

Running the server with five workers:
gunicorn -b 0.0.0.0:8080 --workers=5 wsgi

Arbeiteranzahl

Im Allgemeinen wird angenommen (und akzeptiert), dass Anwendungen eher I/O-gebunden als CPU-gebunden sind. Das bedeutet, dass der Engpass nicht durch die Verarbeitungsleistung Ihres virtuellen Servers verursacht wird, sondern stattdessen durch die Festplatten. Die Idee ist: Wenn ein Arbeiter mit den Festplattenoperationen beschäftigt ist, nutzt ein anderer weiterhin die CPU, um Anfragen zu bearbeiten.

Daher wird die empfohlene Anzahl an Arbeiter in der Regel mit der folgenden einfachen Formel festgelegt:

(2 Workers * CPU Cores) + 1
---------------------------
For 1 core  -> (2*1)+1 = 3
For 2 cores -> (2*2)+1 = 5
For 4 cores -> (2*4)+1 = 9

Sie können die Anzahl der Arbeiter angeben, indem Sie das Argument --workers=[n] übergeben.

Verwendung :

Example: gunicorn --workers=[number of workers]
gunicorn --workers=5

Hinweis: Das obige Szenario gilt nicht unbedingt für nicht-blockierende Arbeiter.

Socket-Einstellungen

Die Funktionsweise der Socket-Bindings ist wie folgt:

Example: gunicorn -b [address:port]
gunicorn -b 127.0.0.1:8080

Hinweis: Wenn eine Anwendung so eingestellt ist, dass sie auf eingehende Verbindungen an 127.0.0.1 hört, ist es nur möglich, lokal darauf zuzugreifen. Wenn Sie jedoch 0.0.0.0 verwenden, akzeptiert sie auch Verbindungen von außen.

Auswahl des Arbeitertyps

Gunicorn, wie wir besprochen haben, bot die Möglichkeit, mit verschiedenen Arten von Arbeitern zu arbeiten.

Für die Mehrheit der Einsätze wird der Standardarbeitstyp - sync - ausreichen und wird standardmäßig bereitgestellt, wodurch keine explizite Einstellung erforderlich ist.

Für andere Arbeiter beachten Sie bitte, dass Sie sie als Abhängigkeiten installieren müssen.

Verwendung :

Example: gunicorn -k [worker]
gunicorn -k sync    # or;
gunicorn -k gevent  # ..

Verfügbare Typen:

  • Synchronisieren
  • Eventlet
  • gevent
  • tornado

Anzahl der gleichzeitigen Verbindungen für Eventlet/Gevent

Um die Anzahl der gleichzeitigen Verbindungen für Eventlet- und Gevent-Arbeiter zu ändern:

Example: gunicorn -k [worker] --worker-connections [number]
gunicorn -k gevent --worker-connections 1001

Zugriffsprotokolle

Wenn Sie die Datei für den Schreiben von Zugriffsprotokollen ausdrücklich festlegen möchten:

Example: gunicorn --access-logfile [file]
gunicorn --access-logfile acclogs

Standardmäßig ist diese Option auf Keine eingestellt.

Fehlerprotokolle

Um eine Datei anzugeben, in die Fehlermeldungen geschrieben werden sollen, verwenden Sie diese Einstellung.

Example: gunicorn --log-file [file]
gunicorn --log-file error_logs.log

Protokollebene

Dies wird verwendet, um die Granularität der Fehlerprotokollausgaben festzulegen. Mögliche Optionen sind:

  • debug
  • Info
  • Warnung
  • Fehler
  • kritisch

Verwendung :

 # Example: gunicorn --log-level [level]
 gunicorn --log-level error

Prozessbenennung

Wenn Sie Dienstprogramme wie top verwenden, um Ihre Prozesse zu überwachen, können Sie diese Einstellung verwenden, um ihnen einen aussagekräftigeren Namen zu geben, was Ihnen bei der Aufgabe helfen sollte.

Example: gunicorn --name [name]
gunicorn --name my_application

Nginx konfigurieren

Nachdem wir gelernt haben, wie man Gunicorn konfiguriert und ausführt, müssen wir nun dasselbe mit Nginx tun, um mit dem Gunicorn-Server zu kommunizieren, der die Anwendung ausführt. Dazu müssen wir die Konfigurationsdatei von Nginx: nginx.conf modifizieren.

Führen Sie den folgenden Befehl aus, um “nginx.conf ” zu öffnen und mit dem Texteditor nano zu bearbeiten:

sudo nano /etc/nginx/nginx.conf

Danach können Sie die Datei mit der folgenden Beispielkonfiguration ersetzen, um Nginx als Reverse-Proxy zu konfigurieren, der mit Ihrer Anwendung kommuniziert.

Hinweis: Um mehr über die Einbindung von SSL-Unterstützung zu erfahren, lesen Sie bitte zuerst diesen Artikel: Ein SSL-Zertifikat auf Nginx erstellen.

Beispielkonfiguration für Webanwendungen:

worker_processes 1;

events {

    worker_connections 1024;

}

http {

    sendfile on;
    
    gzip              on;
    gzip_http_version 1.0;
    gzip_proxied      any;
    gzip_min_length   500;
    gzip_disable      "MSIE [1-6]\.";
    gzip_types        text/plain text/xml text/css
                      text/comma-separated-values
                      text/javascript
                      application/x-javascript
                      application/atom+xml;

    # Configuration containing list of application servers
    upstream app_servers {
    
        server 127.0.0.1:8080;
        # server 127.0.0.1:8081;
        # ..
        # .
    
    }

    # Configuration for Nginx
    server {
    
        # Running port
        listen 80;

        # Settings to serve static files 
        location ^~ /static/  {
        
            # Example:
            # root /full/path/to/application/static/file/dir;
            root /app/static/;
        
        }
        
        # Serve a static file (ex. favico)
        # outside /static directory
        location = /favico.ico  {
        
            root /app/favico.ico;
        
        }

        # Proxy connections to the application servers
        # app_servers
        location / {
        
            proxy_pass         http://app_servers;
            proxy_redirect     off;
            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-Host $server_name;
        
        }
    }
}

Nachdem Sie die Konfiguration geändert haben, drücken Sie CTRL+X und bestätigen Sie mit Y, um zu speichern und zu beenden. Sie müssen Nginx neu starten, damit die Änderungen wirksam werden.

Führen Sie Folgendes aus, um Nginx neu zu starten:

sudo service nginx stop
sudo service nginx start

Hinweis: Um mehr über Nginx zu erfahren, lesen Sie bitte unseren Artikel: So konfigurieren Sie den Nginx-Webserver auf einem VPS.

Verschiedene Tipps und Vorschläge

Firewall:

  • Einrichten einer Firewall mit IP Tables

SSH sichern:

  • Wie man SSH mit fail2ban auf Ubuntu schützt
  • Wie man SSH mit fail2ban auf CentOS 6 schützt

Alarme erstellen:

  • Wie man E-Mail-Alerts auf einem CentOS VPS für die Systemüberwachung sendet

Überwachen und tägliches Beobachten der Serverzugriffsprotokolle:

  • Wie man Logwatch Log-Analyzer und Reporter installiert und verwendet

Eingereicht von: O.S. Tezer