Einleitung

Im vorherigen Artikel haben wir den Prozess des Aufbaus eines maschinellen Lernmodells für die Stimmungsanalyse durchlaufen, das in einer Flask-Anwendung gekapselt war. Diese Flask-Anwendung verwendet eine Stimmungsanalyse, um Tweets als positiv oder negativ zu kategorisieren. Das komplette Projekt ist bereit zur Implementierung und wird auf GitHub versioniert. Im weiteren Verlauf werden wir uns nun mit der Verwendung von Gunicorn und Nginx befassen, um diese Flask-Anwendung auf einem Cloud-Server bereitzustellen und sicherzustellen, dass das Modell für maschinelles Lernen skalierbar und in einer Produktionsumgebung zugänglich ist.

Sie können dem vorherigen Artikel folgen Wie stelle ich ein Modell für maschinelles Lernen mit Flask bereit?

Wir machen dort weiter, wo wir aufgehört haben, und verwenden Gunicorn und NGINX, um diese Flask-Anwendung auf einem Cloud-Server bereitzustellen. In diesem Beitrag wird erläutert, wie eine Flask-Anwendung, die ursprünglich lokal für die Bereitstellung von maschinellem Lernen gehostet wurde, in die Cloud verschoben wird.

Schritte enthalten

• Richten Sie eine AWS EC2-Instanz ein: Starten Sie eine AWS EC2-Instanz mit Ubuntu als Betriebssystem. Konfigurieren Sie Sicherheitsgruppen, um eingehenden Datenverkehr zuzulassen.
• SSH in die EC2-Instanz: Verwenden Sie SSH, um von Ihrem lokalen MacWeis aus eine Verbindung zu Ihrer EC2-Instanz herzustellen. Für die Verbindung mit Ihrem lokalen System benötigen wir ein SSH-Schlüsselpaar (öffentlich und privat).
• Flask-Anwendung bereitstellen: Übertragen Sie die Flask-Anwendungsdateien auf die EC2-Instanz. Wenn sich das Modell bereits auf Git Hub befindet, klonen Sie es in die EC2-Ubuntu-Instanz. Richten Sie dann eine virtuelle Umgebung ein und installieren Sie die erforderlichen Python-Pakete oder die Anforderungsdatei mit pip im Verzeichnis. Testen Sie, ob die Flask-Anwendung in der EC2-Umgebung ordnungsgemäß ausgeführt wird.
• Abhängigkeiten installieren: Aktualisieren Sie die Paketlisten für Upgrades und installieren Sie erforderliche Abhängigkeiten, z. B. Python, Pip und alle anderen Bibliotheken, die für Ihre Flask-Anwendung erforderlich sind.
• Gunicorn installieren und konfigurieren: Installieren Sie Gunicorn, einen WSGI-HTTP-Server für Python-Anwendungen. Erstellen Sie eine Gunicorn-Servicedatei, um den Bewerbungsprozess zu verwalten. Starten Sie den Gunicorn-Dienst und aktivieren Sie ihn für die Ausführung im Hintergrund.
• Installieren und konfigurieren Sie NGINX: Installieren Sie NGINX, einen Hochleistungs-Webserver und Reverse-Proxy. Konfigurieren Sie NGINX so, dass eingehende HTTP-Anfragen an den Gunicorn-Server weitergeleitet werden. Richten Sie Serverblöcke (virtuelle Hosts) für Ihre Flask-Anwendung ein.
• Domänennamen konfigurieren (optional): Wenn Sie einen Domänennamen haben, konfigurieren Sie die DNS-Einstellungen so, dass sie auf die öffentliche IP-Adresse Ihrer EC2-Instanz verweisen. Wenn nicht, können Sie direkt über die öffentliche IP-Adresse auf Ihre Flask-Anwendung zugreifen.
• Sichern Sie die Anwendung: Aktivieren Sie HTTPS für eine sichere Kommunikation zwischen Clients und dem Server. Besorgen Sie sich ein SSL/TLS-Zertifikat (z. B. Let's Encrypt) und konfigurieren Sie NGINX für die Verwendung.
• Testen Sie die Bereitstellung: Sobald alles eingerichtet ist, testen Sie Ihre bereitgestellte Flask-Anwendung, indem Sie über einen Webbrowser darauf zugreifen oder Anfragen mit cURL oder Postman senden.

Wenn Sie diese Schritte befolgen, stellen wir Ihre Flask-Anwendung für maschinelles Lernen erfolgreich auf einer AWS EC2-Instanz bereit. Dabei nutzen wir Gunicorn als WSGI-Server und NGINX als Reverse-Proxy-Server, um eingehende Anfragen effizient und sicher zu verarbeiten.

Bevor wir mit den praktischen Übungen beginnen, wollen wir verstehen, wie es gemacht wird.

Die Kommunikation verstehen: Flask, Gunicorn und Nginx

             +-----------------------------+
             |           Client            |
             +-----------------------------+
                          |
                          |
             +------------v-------------+
             |        NGINX (Port 80)   |
             +------------+-------------+
                          |
                          |
             +------------v-------------+
             |       Gunicorn           |
             |     (WSGI Server)        |
             +------------+-------------+
                          |
                          |
             +------------v-------------+
             |   Flask Application      |
             |       (Python)           |
             +--------------------------+

Kolben: Das Zentrum der Anwendung

Flask ist ein leichtes und flexibles Python-Webframework, das die Tools zum Erstellen von Webanwendungen/-diensten bereitstellt. Es ist die Grundlage Ihres Stimmungsanalysedienstes, der eingehende Webanfragen verarbeitet, sie mithilfe Ihres maschinellen Lernmodells verarbeitet und die Analyseergebnisse zurückgibt. Flask fungiert als Anwendungsschicht in unserem Stack.

Wir haben die Flask-Anwendung bereits im vorherigen Artikel erstellt. Und klonen Sie es mit dem Befehl.

https://github.com/Geek-shikha/Flask_model_sentiment_analysis.git

Flask allein kann nicht mehrere Anfragen gleichzeitig bearbeiten; Dann kommt Gunicorn ins Spiel.

Gunicorn: Der Python-WSGI-HTTP-Server

Gunicorn fungiert als Zwischenschicht, die mit Flask interagiert. Es handelt sich um einen Python-WSGI-HTTP-Server, der für UNIX-Systeme entwickelt wurde und eine einfache, aber effiziente Möglichkeit bietet, Python-Webanwendungen bereitzustellen. Wenn Sie Ihre Flask-App mit Gunicorn ausführen, wird ein WSGI-Server erstellt, der mit der Flask-Anwendung kommuniziert. Gunicorn verwaltet mehrere Worker-Prozesse, um eingehende Anfragen zu bearbeiten, die Last zu verteilen und die Fähigkeit zur Handhabung gleichzeitiger Benutzer zu erhöhen. Nein. Die Anzahl der Worker und Threads hängt von der Anzahl der Kerne des Systems ab, 2*Kerne +1.

Bis Sie Multithreading haben, gibt es keinen separaten Speicherplatz. Ein einzelner Worker kann mehrere Anfragen von den Clients parallel bearbeiten.

Warum ist Gunicorn erforderlich?

Aus verschiedenen Gründen ist Gunicorn oder Green Unicorn eine entscheidende Komponente beim Hosten von Flask-Anwendungen. Erstens kann der integrierte Entwicklungsserver von Flask nicht mehrere Anfragen gleichzeitig verarbeiten, was ihn für Produktionsumgebungen ungeeignet macht. Sein Pre-Fork-Worker-Modell ermöglicht Skalierbarkeit durch die Ausführung zahlreicher Worker-Prozesse oder Threads und bewältigt so den erhöhten Datenverkehr effektiv. Der Lastausgleich von G Unicorn verteilt Anfragen gleichmäßig und verbessert so die Leistung bei hoher Last. Gunicorn ist kompatibel mit der WSGI-Spezifikation und lässt sich nahtlos in Flask und andere WSGI-kompatible Frameworks integrieren, was die Bereitstellung vereinfacht. Gunicorn bietet wesentliche Funktionen wie Parallelität, Skalierbarkeit, Leistung und Kompatibilität, was es für die Bereitstellung von Flask-Anwendungen in der Produktion unverzichtbar macht.

Nginx: Der Frontline-Reverse-Proxy

Nginx ist ein leistungsstarker Webserver, der für seine Stabilität, einfache Konfiguration und geringen Ressourcenverbrauch bekannt ist. In unserer Bereitstellung ist Nginx als Reverse-Proxy konfiguriert und sitzt vor Gunicorn. Es empfängt Kundenanfragen und leitet sie an Gunicorn weiter, das wiederum mit der Flask-Anwendung kommuniziert. Nginx ist auch für die Bereitstellung statischer Dateien, die SSL/TLS-Verschlüsselung und möglicherweise den Lastausgleich verantwortlich, wenn Ihre Anwendung auf mehrere Server skaliert wird.

Warum Nginx?

Darüber hinaus zeichnet sich NGINX dank seiner robusten Lastausgleichsfunktionen und Puffermechanismen durch die gleichzeitige Verarbeitung mehrerer Modelle oder Anwendungen aus. Während Gunicorn möglicherweise mit der Geschwindigkeit bei der Verarbeitung mehrerer Anfragen zu kämpfen hat, kann NGINX diese Arbeitslast effizient bewältigen, indem es Anfragen puffert und so einen reibungsloseren Betrieb gewährleistet. Darüber hinaus bietet NGINX wesentliche Funktionen wie SSL-Terminierung, Token-Authentifizierung und Lastausgleich, was es für die Sicherung und Optimierung von Flask-Anwendungen unverzichtbar macht. Für weitere Skalierbarkeit und Flexibilität können Docker oder Kubernetes neben NGINX integriert werden, was eine dynamische Skalierung und eine vereinfachte Verwaltung von Diensten ermöglicht. Ob auf AWS oder Kubernetes bereitgestellt, NGINX bleibt ein vielseitiges und leistungsstarkes Tool zum Hosten von Flask-Anwendungen im großen Maßstab.

Pre Voraussetzungen

Bevor Sie die Schritte zum Bereitstellen Ihres Modells ausführen, sollten Sie Folgendes verstehen und haben.

AWS-Konto: Sie benötigen ein AWS-Konto, um auf EC2 und andere AWS-Dienste zuzugreifen. Wenn Sie noch kein Konto haben, können Sie sich auf der AWS-Website für eines anmelden.

Wenn Ihre App mit einem Namen angezeigt werden soll, muss ein Domänenname konfiguriert sein, der auf Ihren Server verweist. Sie können eines kostenlos erhalten Freenom. Dies benötigen wir hier nicht, da wir direkt die öffentliche IP-Adresse verwenden.

Verständnis der WSGI-Dateispezifikation und Server, Proxy und Ports. Ein wenig Verständnis wird auch helfen.

Bereitstellen eines Modells für maschinelles Lernen mithilfe von Flask auf AWS mit Gunicorn und Nginx

SCHRITT 1: Richten Sie eine AWS EC2-Instanz ein

Starten Sie eine AWS EC2-Instanz mit Ubuntu als Betriebssystem. Ein Mikrodienst würde gut funktionieren. Wir behalten den Namen der Instanz bei sentiment_analysis_server. Sie können frei wählen, was Ihnen gefällt. Bedenken Sie jedoch, dass die Serviceauswahl der Instanz von der Größe der Anwendung abhängt, die Sie hosten möchten.

Erstellen Sie ein Schlüsselpaar, um über SSH eine sichere Verbindung mit Ihrem EC2 herzustellen. Wenn Sie eine EC2-Instanz erstellen, geben Sie ein Schlüsselpaar an und die entsprechende private Schlüsseldatei (.pem) wird zur Authentifizierung Ihrer SSH-Verbindung zur Instanz verwendet. Verwenden Sie ein Schlüsselpaar vom Typ RSA und befolgen Sie die folgenden Schritte.

1. Schlüsselpaar erstellen: Klicken Sie auf die Schaltfläche „Schlüsselpaar erstellen“, um das Schlüsselpaar zu generieren.
2. Privaten Schlüssel herunterladen: Sobald das Schlüsselpaar erstellt ist, wird automatisch eine private Schlüsseldatei (.pem) auf Ihren lokalen Computer heruntergeladen. Diese private Schlüsseldatei authentifiziert SSH-Verbindungen zu Ihren EC2-Instanzen.

Starten Sie Ihre Instanz mit Sicherheitskonfigurationen, die Port- und HTTP-Verkehr zulassen. Nachdem Sie Ihre Instanz gestartet und eine Verbindung hergestellt haben, kopieren Sie den SSH-Befehl daraus, damit Sie ihn auf Ihrem lokalen Terminal veröffentlichen können, um remote auf die Instanz zuzugreifen. Im folgenden Bild müssen Sie den grün hervorgehobenen Teil kopieren und in Ihr lokales Terminal/Terminal einfügen.

SCHRITT 2: SSH in die EC2-Instanz

Öffnen Sie das Terminal Ihres Computers. Wenn sich Ihre private Schlüsseldatei (.pem) in einem Verzeichnis befindet, müssen Sie den vollständigen Pfad zur Schlüsseldatei angeben, wenn Sie den SSH-Befehl zum Herstellen einer Verbindung mit Ihrer EC2-Instanz verwenden. So können Sie es machen:

Nehmen wir an, Ihr Schlüssel (.pem-Datei) befindet sich unter „Downloads“. Anschließend müssen Sie dort Ihren SSH-Befehl platzieren. Sie müssen also lediglich Ihr Terminal öffnen, zum Download-Verzeichnis navigieren und dort Ihren Befehl einfügen.

cd ~/Downloads

Fügen Sie nun Ihren SSH-Befehl ein, der wie im Beispiel aussehen könnte: ssh -i „sentiment_analysiskey.pem“ [E-Mail geschützt]

SCHRITT 3: Installieren der erforderlichen Komponenten aus den Ubuntu-Repositories

Der erste Schritt besteht darin, alle notwendigen Komponenten aus den Ubuntu-Repositories zu installieren. Dazu gehören die Python-Komponenten, die Pip verwaltet, und der Python-Paketmanager. Die zum Zusammenbau von Gunicorn-Komponenten erforderlichen Python-Entwicklungsdateien werden ebenfalls bereitgestellt. Wenn Sie die Pakete installieren, mit denen Sie Ihre Python-Umgebung erstellen können, müssen Sie zunächst den lokalen Paketindex aktualisieren.

sudo apt update 
sudp apt upgrade 

Installieren Sie dann den Befehl Python-pip, um Pip und die virtuelle Umgebung zu installieren.

sudo apt install python3-pip
sudo apt install python3-venv

Installieren Sie dann das Net-Stat-Paket. Das Paket „net-tools“ zeigt netzwerkbezogene Informationen an, z. B. aktive Netzwerkverbindungen, Routing-Tabellen, Schnittstellenstatistiken usw.

sudo apt install net-tools

sudo apt install net-tools

netstat tuln #after installing run this command 

Es zeigt eine Liste der aktiven Netzwerkverbindungen und Überwachungsports auf dem System an:

Installieren Sie dann das Firewall-Paket: Das ufw-Paket (Uncomplicated Firewall) ist ein Frontend für die Verwaltung der iptables-Firewallregeln auf Ubuntu und anderen Debian-basierten Linux-Distributionen. Es bietet eine vereinfachte Schnittstelle zum Konfigurieren von Firewall-Regeln und erleichtert so die Einrichtung eines wichtigen Firewall-Schutzes für Ihr System

• sudo ufw aktivieren: Aktiviert die Firewall.
• Sudo ufw erlauben /: Dieser Befehl ermöglicht eingehende Verbindungen über einen bestimmten Port und ein bestimmtes Protokoll (z. B. erlaubt sudo ufw 22/TCP, SSH-Verbindungen zu ermöglichen).
• Sudo ufw-Status: Zeigt den aktuellen Status und die Regeln der Firewall an.

sudo apt install ufw #
sudo ufw allow 22 #ssh access
sudo ufw allow 5000  #5000 port for flask app test 

sudo ufw status 

1. Sudo ufw erlaubt 5000: Dies ermöglicht eingehende Verbindungen auf Port 5000. Standardmäßig ist sowohl TCP- als auch UDP-Verkehr auf diesem Port zulässig. Wir werden unsere Flask-App auf 5000 ausführen, daher muss der Flask-App-Dienst, der auf Port 5000 läuft, über das Netzwerk erreichbar sein.
2. Sudo ufw erlaubt 22: Dieser Befehl ermöglicht eingehende SSH-Verbindungen auf Port 22. SSH wird für den Fernzugriff auf Ihr System verwendet, und das Zulassen von Verbindungen auf Port 22 ermöglicht Ihnen eine sichere Verbindung zu Ihrem Server über SSH. Das ist wichtig; Sie sollten dies nicht deaktivieren, da Sie dann nicht aus der Ferne auf Ihr SSH zugreifen können.

Schritt 4: Stellen Sie die Flask-Anwendung bereit und richten Sie die Anwendung ein

Flask-Anwendung bereitstellen: Übertragen Sie die Flask-Anwendungsdateien auf die EC2-Instanz. Wenn sich das Modell bereits auf Git Hub befindet, klonen Sie es in die EC2-Ubuntu-Instanz. Richten Sie dann eine neue virtuelle Umgebung ein und installieren Sie die erforderlichen Python-Pakete oder die Anforderungsdatei im Verzeichnis mit pip. Anschließend wird die Test Flask-Anwendung ordnungsgemäß in der EC2-Umgebung ausgeführt.

In unserem Fall klonen wir ein Git-Repository, das wir im letzten Artikel verwendet haben, um die Stimmung eines Tweets zu analysieren.

Stellen Sie jedoch zunächst sicher, dass Git installiert ist. Wenn es installiert ist, führen Sie den Befehl aus: git clone -b master –single-branch https://github.com/Geek-shikha/Flask_model_sentiment_analysis.git

git --version # if this exists you need not to sudo apt install git 
git clone -b master --single-branch 
https://github.com/Geek-shikha/Flask_model_sentiment_analysis.git #same line 

#after cloning the repository go tot the directory and list all the files 
cd Flask_model_sentiment_analysis
ls 

Hinweis: Wenn Sie das Repository klonen, wird keine app.py-Datei angezeigt. Stattdessen ist myproject.py vorhanden, was wir benötigen.

Es gibt eine vorhandene virtuelle Umgebung, die wir zuvor beim lokalen Erstellen einer Flask-App erstellt haben. Wir müssen eine neue virtuelle Umgebung schaffen, um Fehler oder Unstimmigkeiten zu vermeiden. Die neue virtuelle Umgebung trägt den Namen „myprojectenv“ und muss aktiviert werden.

python -m venv myprojectenv #virtual env named as myprojectenv
source myprojectenv/bin/activate #activate the virtual environment

Installieren Sie die in „requirements.txt“ gespeicherten Python-Bibliotheken

pip install -r requirements.txt #install the dependencies like flask, nltk etc.

Testen Sie nun Ihre Python Flask-Anwendung und führen Sie sie aus

python3 myproject.py

Wenn Sie dies ausführen, können Sie im Terminal eine Ausgabe wie diese sehen:

Um zu sehen, ob es funktioniert. Rufen Sie die IP-Adresse Ihres Servers gefolgt von:5000 in Ihrem Webbrowser auf. In Ihrem Webbrowser lautet Ihre Server-IP 5000, z. B. http://server_pub_ip:5000. Nehmen wir an, die Server-IP lautet  23.124.09.133 Dann setzen http://23.124.09.133:5000 

Schritt 5: WSGI-Datei

Erstellen Sie als Nächstes eine Datei, die als Einstiegspunkt für Ihre Bewerbung dient. Diese Datei weist den Gunicorn-Server an, mit der Anwendung zu interagieren.

Erstellen Sie eine wsgi.py-Datei im Ordner Flask_model_sentiment_analysis

nano ~/Flask_model_sentiment_analysis/wsgi.py 

Importieren Sie in dieser Datei die Flask-Instanz aus unserer Anwendung, die wir myproject.py genannt haben, und führen Sie sie dann aus:

from myproject import app

if __name__ == "__main__":
    app.run()

Sie können auch sudo apt und unicorn installieren, wenn ein Fehler auftritt.

Schritt 6: Gunicorn-Konfiguration

Beginnen wir mit der Konfiguration von Gunicorn und der Bindung der wsgi-App an Port 5000

Der Befehl „unicorn configure“ startet einen Gunicorn-Server, der auf eingehende Verbindungen an Port 5000 von jeder IP-Adresse wartet und die in der Datei wsgi.py definierte WSGI-Anwendung mit dem Namen „app“ bereitstellt.

gunicorn --bind 0.0.0.0:5000 wsgi:app

Ausgang:

Überprüfen Sie, ob es funktioniert. Besuchen Sie die IP-Adresse Ihres Servers, gefolgt von:5000 in Ihrem Webbrowser: In Ihrem Webbrowser lautet die IP-Adresse Ihres Servers 5000, z. B. http://server_pub_ip:5000; Nehmen wir an, die Server-IP lautet  23.124.09.133 Dann setzen http://23.124.09.133:5000 

Sie sollten eine Ausgabe wie diese erhalten:

Wenn Sie die richtige Antwort erhalten, beenden Sie den Dienst; Sie können Strg+C drücken und dann Ihre virtuelle Umgebung deaktivieren, indem Sie den Befehl eingeben. Anschließend erstellen Sie die System- und Service-Unit-Datei. Diese Aktion ermöglicht es dem Init-System von Ubuntu, Gunicorn automatisch zu starten und die Flask-Anwendung beim Serverstart zu hosten.

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

Fügen Sie den folgenden Inhalt hinzu:

[Unit]
Description=Gunicorn instance to serve myproject
After=network.target

[Service]
User=ubuntu
Group=www-data
WorkingDirectory=/home/ubuntu/Flask_model_sentiment_analysis
Environment="PATH=/ubuntu/Flask_model_sentiment_analysis/myprojectenv/bin"
ExecStart=/home/ubuntu/Flask_model_sentiment_analysis/myprojectenv/bin/gunicorn 
--workers 3 --bind unix:myproject.sock -m 007 w>
[Install]
WantedBy=multi-user.target

• [Einheit]: In diesem Abschnitt werden Metadaten und Abhängigkeiten für die Einheit angegeben.
• Beschreibung: Beschreibt den Dienst.
• After = network.target: Zeigt an, dass dieses Gerät startet, nachdem das Netzwerk hochgefahren ist, und stellt die Netzwerkkonnektivität sicher, bevor der Dienst startet.
• [Bedienung]: In diesem Abschnitt werden die Parameter für den Dienst definiert.
• Benutzer=ubuunit: Es gibt das Benutzerkonto an, unter dem der Dienst ausgeführt werden soll.
• Gruppe=www-data: Legt die Gruppe für den Dienst fest.
• Arbeitsverzeichnis: Gibt das Arbeitsverzeichnis für den Dienst an.
• Environment=“PATH=/ubuntu/Flask_model_sentiment_analysis/myprojectenv/bin“: Diese Variable definiert die Umgebungsvariablen des Dienstes und legt die PATH-Variable explizit so fest, dass sie das Binärverzeichnis der virtuellen Umgebung enthält.
• AusführenStart: Gibt den Befehl zum Starten des Dienstes an. In diesem Fall startet es Gunicorn mit bestimmten Optionen:
• –Arbeiter 3: Konfiguriert Gunicorn für die Verwendung von drei Arbeitsprozessen.
• –bind unix: mein project.sock: Gibt die Socket-Datei an, über die Gunicorn mit dem Webserver (z. B. Nginx oder Apache) kommuniziert.
• -m 007: Setzt die Maske auf 007 und steuert die Berechtigungen der von Gunicorn erstellten Dateien.
• wsgi:app: Gibt den Speicherort der bereitzustellenden WSGI-Anwendung an.
• [Installieren]: In diesem Abschnitt werden Installationsinformationen für das Gerät definiert.
• WantedBy=multi-user.target: Gibt das Ziel an, in dem diese Einheit installiert werden soll. In diesem Fall ist es auf Mehrbenutzer eingestellt. Target, ein Standardziel für Benutzersysteme, gibt an, dass der Dienst beim Systemstart automatisch gestartet werden soll.

Zusammenfassend lässt sich sagen, dass diese Systemeinheitsdatei Gunicorn für die Bereitstellung einer Flask-Anwendung mit bestimmten Konfigurationen einrichtet und sicherstellt, dass der Dienst beim Systemstart automatisch gestartet wird.

Es ist Zeit, den von Ihnen erstellten Gunicorn-Dienst zu starten und zu aktivieren, damit er beim Booten startet:

sudo systemctl start myproject
sudo systemctl enable myproject
sudo systemctl status myproject#check the status of your service file for errors, ifany

 Wenn der Befehl nicht funktioniert, verwenden Sie diesen, um „sudo systemctl daemon-reload“ neu zu laden.

Wenn Sie jeden Schritt befolgt haben, sollten keine Fehler auftreten. Wenn der Fehler jedoch weiterhin besteht, beheben Sie ihn. Möglicherweise liegt ein Fehler im Pfad oder in der Umgebung in der Servicedatei vor. Überprüfe vorsichtig

Schritt 7: NGINX installieren und konfigurieren

Der Gunicorn-Anwendungsserver ist betriebsbereit und wartet auf Anfragen über die Socket-Datei im Projektverzeichnis. Jetzt konfigurieren wir Nginx so, dass Webanfragen an diesen Socket weitergeleitet werden, indem wir geringfügige Änderungen an seiner Konfigurationsdatei vornehmen. Dazu müssen wir zuerst Nginx installieren

sudo apt install nginx

Beginnen Sie mit der Generierung einer neuen Serverblock-Konfigurationsdatei im Verzeichnis „sites-available“ von Nginx. Benennen Sie diese Datei „Projekt“, um Verwirrung zu vermeiden. Wir haben zuvor den Namen myproject.py verwendet

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

um den Inhalt der Datei hinzuzufügen, die über eine Nginx-Serverblockkonfiguration verfügt, die sicherstellt, dass eingehende HTTP-Anfragen an die angegebene Server-IP-Adresse über die Unix-Socket-Datei an den Gunicorn-Anwendungsserver weitergeleitet werden, sodass die Flask-Anwendung die Anfragen verarbeiten kann. Speichern Sie die Datei und verlassen Sie den Editor.

server {
    listen 80;
    server_name 3.110.196.110; #your server public ip 

    location / {
        include proxy_params;
        proxy_pass http://unix:/home/ubuntu/Flask_model_sentiment_analysis/myproject.sock;
    }
}

• Server { … }: Dieser Block definiert eine Serverkonfiguration innerhalb von Nginx. Es kapselt die Konfigurationseinstellungen für die Bearbeitung von Anfragen für einen bestimmten Server.
• Hören Sie 80: Diese Anweisung gibt an, dass Nginx auf eingehende HTTP-Anfragen auf Port 80, dem Standardport für HTTP-Verkehr, warten soll.
• Servername 3.110.196.110: Diese Anweisung legt den Hostnamen oder die IP-Adresse des Servers fest. In diesem Fall ist sie auf 3.110.196.110 eingestellt, die durch die öffentliche IP-Adresse Ihres Servers ersetzt werden sollte.
• Standort / { … }: Dieser Block definiert, wie Nginx Anfragen für das Stammverzeichnis / des Servers behandeln soll.
• Proxy_params einschließen: Diese Direktive stellt Konfigurationseinstellungen aus der Datei „proxy_params“ bereit. Diese Einstellungen enthalten normalerweise Proxy-bezogene Konfigurationen, wie z. B. Proxy-Header.
• Proxy_pass http://unix:/home/ubuntu/Flask_model_sentiment_analysis/myproject.sock: Diese Direktive gibt an, dass Nginx eingehende Anfragen an die angegebene Unix-Socket-Datei weiterleiten soll, die sich unter /home/ubuntu/Flask_model_sentiment_analysis/myproject.sock befindet. Hier hört Gunicorn auf Anfragen. Nginx fungiert als Reverse-Proxy, leitet Anfragen an Gunicorn weiter und sendet die Antworten an den Client zurück.

Jetzt aktivieren und auf Fehler testen

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

• sudo ln -s /etc/nginx/sites-available/myproject /etc/nginx/sites-enabled: Dieser Befehl erstellt einen symbolischen Link mit dem Namen „myproject“ im Verzeichnis „sites-enabled“, der auf die Konfigurationsdatei im Verzeichnis „sites-available“ verweist. Dadurch aktivieren Sie die Serverblockkonfiguration für Ihr Projekt.
• Sudo nginx -t: Dieser Befehl testet die Nginx-Konfiguration auf Syntaxfehler. Es prüft, ob die Nginx-Konfigurationsdateien, einschließlich des neu aktivierten myproject-Serverblocks, korrekt geschrieben und gültig sind. Sollten Fehler auftreten, werden diese im Rahmen dieses Tests gemeldet.

Starten Sie Nginx neu, da wir die Konfigurationen aktualisiert haben

sudo systemctl restart nginx

Aktualisieren der Firewall für Nginx

sudo ufw allow 'Nginx Full'

Da wir den 5000-Port nicht benötigen, können wir ihn mit dem Befehl „sudo ufw deleteallow 5000“ deaktivieren, aber wir müssen Port 22 nicht deaktivieren.

Navigieren Sie nun in Ihrem Webbrowser zum Domänennamen (oder der IP-Adresse) Ihres Servers und Sie sehen die Ausgabe:

Wenn Sie einen Fehler wie 502 Gateway sehen, müssen Sie einige Berechtigungen ändern. Verwenden Sie den Befehl

sudo chmod 755 /home/ubuntu

Wenn Sie Ihren Server für die Anwendung testen, sollten Sie außerdem http://….. und nicht https verwenden, da die Anwendung nicht gesichert ist.

Wenn Fehler vorliegen, können Sie diese mit folgenden Befehlen überprüfen:

Wenn Sie den Dienst stoppen möchten, können Sie den Befehl verwenden

sudo systemctl stop nginx #stop the service 
sudo systemctl start nginx# to start the service 

Weitere Schritte zur Sicherung der Anwendung

Es gibt weitere Schritte zur Sicherung der Anwendung.  

Aktivieren Sie HTTPS für eine sichere Kommunikation zwischen Clients und dem Server. Besorgen Sie sich ein SSL/TLS-Zertifikat (z. B. Let's Encrypt) und konfigurieren Sie NGINX für die Verwendung. Wir können Certbot verwenden, um die Anwendung zu sichern.

Um Ihren Webserver mit SSL/TLS mit Certbot zu sichern, benötigen Sie normalerweise einen registrierten Domänennamen. Certbot benötigt zum Ausstellen von SSL-Zertifikaten einen Domänennamen, da es vor der Ausstellung des Zertifikats den Domänenbesitz überprüft. Obwohl es technisch möglich ist, anstelle eines Domänennamens eine öffentliche IP-Adresse zu verwenden, wird dies aus mehreren Gründen nicht empfohlen. Eine davon sind die Anforderungen der Zertifizierungsstelle (CA): Zertifizierungsstellen (CAs) wie Let's Encrypt (das Certbot verwendet) verfügen über Richtlinien, die eine Domänenvalidierung erfordern. Sie werden keine SSL-Zertifikate für IP-Adressen ausstellen.

Wenn Sie es sichern möchten, können Sie sudo apt install python3-certbot-nginx verwenden und in der Dokumentation mehr darüber erfahren.

Zusammenfassung

In diesem Artikel haben wir eine grundlegende Flask-Anwendung in einer virtuellen Python-Umgebung erstellt. Wir haben einen WSGI-Einstiegspunkt generiert, der die Kompatibilität mit jedem WSGI-fähigen Anwendungsserver ermöglicht, und dann Gunicorn für die Erfüllung dieser Rolle konfiguriert. Anschließend haben wir eine Systemdienstdatei erstellt, um den Anwendungsserver beim Systemstart automatisch zu starten. Darüber hinaus haben Sie einen Nginx-Serverblock erstellt, der dafür verantwortlich ist, den Web-Client-Datenverkehr an den Anwendungsserver weiterzuleiten, externe Anforderungen effektiv weiterzuleiten und den Server-Datenverkehr mit der Let's Encrypt-Verschlüsselung zu schützen.

• SEO-gestützte Content- und PR-Distribution. Holen Sie sich noch heute Verstärkung.
• PlatoData.Network Vertikale generative KI. Motiviere dich selbst. Hier zugreifen.
• PlatoAiStream. Web3-Intelligenz. Wissen verstärkt. Hier zugreifen.
• PlatoESG. Kohlenstoff, CleanTech, Energie, Umwelt, Solar, Abfallwirtschaft. Hier zugreifen.
• PlatoHealth. Informationen zu Biotechnologie und klinischen Studien. Hier zugreifen.
• Quelle: https://www.analyticsvidhya.com/blog/2024/04/ml-using-flask-on-aws-gunicorn-nginx/