So installierst du Flask mit Nginx und Gunicorn auf Rocky Linux

Flask ist ein in Python geschriebenes Microframework für die Entwicklung moderner Webanwendungen und API (Application Programming Interface). Es basiert auf dem Werkzeug-Toolkit und der Jinja2-Vorlage. Anstatt eine komplexe Architektur zu verwenden, ist Flask ein kleines Web-Framework, das den Kern einfach erweitert und leicht zu erlernen ist, da Flask weniger Code enthält. Flask enthält kein ORM, hat aber trotzdem coole Funktionen wie URL-Routing und eine Template-Engine.

Gunicorn oder „Green Unicorn“ ist ein WSGI HTTP Server mit Pre-Fork Worker Modus. Er wurde vom Ruby Unicorn Projekt portiert. Gunicorn kann mit verschiedenen Web-Frameworks gekoppelt werden, benötigt wenig Server-Ressourcen und ist schnell. Gunicorn steht zwischen deiner Anwendung und dem Webserver. Du kannst Gunicorn also mit Webservern wie Nginx und Apache2 koppeln.

In diesem Lernprogramm zeigen wir dir, wie du das Flask Python Web Framework mit Gunicorn und Nginx auf dem Rocky Linux Server installierst und konfigurierst. Außerdem lernst du, wie du Supervisord als Prozessmanager für die Verwaltung der Python-Flask-Anwendung einrichtest.

Voraussetzungen

Um diesen Lehrgang durchzuführen, brauchst du einige der folgenden Voraussetzungen:

• Einen Rocky Linux Server – Du kannst sowohl Rocky Linux v8 als auch v9 verwenden – Desktop oder Server.
• Einen Nicht-Root-Benutzer mit sudo-Root-Administrator-Rechten.
• Ein Dummy-Domainname für die lokale Entwicklung.

Installieren der Abhängigkeiten

Im ersten Schritt installierst du einige Paketabhängigkeiten, die für die Installation und den Einsatz von Flask Web Framework benötigt werden. Dazu gehören z. B. Python Pip, Nginx und Supervisord.

Alle diese Pakete sind im Rocky Linux Repository verfügbar und können ganz einfach mit dem DNF-Befehl installiert werden.

Stelle zunächst sicher, dass das EPEL-Repository auf deinem System installiert ist. Du kannst es auch einfach mit dem unten stehenden dnf-Befehl installieren und aktivieren.

sudo dnf install epel-release

Installiere nun die Python-Pakete „python3-pip“ und „python3-devel“ sowie den GCC-Compiler mit dem unten stehenden dnf-Befehl. Diese Pakete werden für die Installation von Python-Paketen verwendet.

sudo dnf install python3-pip python3-devel gcc

Wenn du aufgefordert wirst, die Installation zu bestätigen, gib y ein und drücke ENTER, um fortzufahren.

Als nächstes führst du einen weiteren dnf-Befehl aus, um den Nginx-Webserver und die supervisord-Pakete zu installieren. Nginx wird als Reverse Proxy für dein Flask-Projekt verwendet und Supervisord dient zur Verwaltung deines Flask-Anwendungsprozesses.

sudo dnf install nginx supervisor

Gib y ein und drücke ENTER, um die Installation zu bestätigen.

Starte und aktiviere den Nginx-Dienst mit dem Befehl systemctl (siehe unten). Überprüfe dann den Nginx-Dienst, um sicherzustellen, dass er läuft.

sudo systemctl start nginx
sudo systemctl enable nginx

sudo systemctl status nginx

Du wirst die folgende Ausgabe sehen – Der Nginx-Dienst ist aktiviert und wird beim Systemstart automatisch ausgeführt. Der Status des Nginx-Dienstes ist „running“.

Für den Dienst supervisord gibst du den folgenden Befehl ein, um ihn zu starten und zu aktivieren. Überprüfe dann den Status des supervisord-Dienstes, um sicherzustellen, dass er läuft.

sudo systemctl start supervisord
sudo systemctl enable supervisord

sudo systemctl status supervisord

Du wirst sehen, dass der supervisord-Dienst aktiviert ist und beim Start automatisch ausgeführt wird. Und der Status des Supervisord-Dienstes lautet: Er läuft.

Benutzer einrichten

Nachdem du die Paketabhängigkeiten installiert hast, richtest du einen neuen Benutzer ein, der für die Ausführung des Flask-Projekts verwendet werden soll.

Führe den folgenden Befehl aus, um einen neuen Benutzer anzulegen und das Passwort festzulegen. In diesem Beispiel wirst du den neuen Benutzer alice anlegen.

Wenn du aufgefordert wirst, ein neues Passwort zu erstellen, gib dein Passwort ein und wiederhole es.

sudo useradd -m -s /bin/bash alice
sudo passwd alice

Führe nun den folgenden Befehl aus, um den Benutzer alice zur Gruppe„wheel“ hinzuzufügen, damit er den Befehl sudo ausführen kann.

sudo usermod -aG wheel alice

Melde dich schließlich mit dem neuen Benutzer an und führe den Befehl „sudo“ aus, um die Root-Rechte zu überprüfen. Gib dein Passwort ein, wenn du dazu aufgefordert wirst.

su - alice
sudo su

Du solltest nun die Root-Shell deines Rocky Linux-Rechners sehen.

Einrichten der virtuellen Python-Umgebung

In diesem Schritt richtest du die virtuelle Python-Umgebung für das Web-Framework Flask ein.

Melde dich mit folgendem Befehl als dein Benutzer an.

su - alice

Erstelle mit dem folgenden mkdir-Befehl ein neues Flask-Installationsverzeichnis„/var/www/myflask“.

sudo mkdir -p /var/www/myflask

Ändere die Eigentümerschaft und die Rechte des Flask-Installationsverzeichnisses mit dem folgenden Befehl. Der Eigentümer sollte der Benutzer alice mit der Berechtigung 755 sein.

sudo chown -R alice:alice /var/www/myflask
sudo chmod 755 /var/www/myflask

Verschiebe nun dein Arbeitsverzeichnis in das Flask-Installationsverzeichnis „/var/www/myflask“ und erstelle eine neue virtuelle Python-Umgebung mit dem unten stehenden Python-Befehl.

cd /var/www/myflask
python3 -m venv myenv

Du wirst sehen, dass ein neues Verzeichnis„myenv“ erstellt wird.

Als Nächstes aktivierst du die virtuelle Python-Umgebung mit dem folgenden Befehl. Wenn sie aktiviert ist, siehst du, dass das Format der Eingabeaufforderung in „(myenv alice@hostname“ geändert wird.

source myenv/bin/activate

Um die virtuelle Umgebung zu deaktivieren, musst du den folgenden Befehl ausführen.

deactivate

Installation von Flask und Gunicorn

Vergewissere dich vor der Installation von Flask, dass du dich in der virtuellen Umgebung befindest, oder führe einfach den folgenden Befehl aus, um dich einzuloggen.

su - alice

cd /var/www/myflask
source myenv/bin/activate

Installiere nun Flask und Gunicorn mit dem folgenden pip-Befehl. Dadurch werden Flask und Gunicorn in der virtuellen Umgebung installiert, nicht in der systemweiten.

pip3 install flask gunicorn

Nachdem Flask und Gunicorn installiert sind, kannst du die erste Anwendung mit Flask Web Framework erstellen.

Erste Flask-Anwendung erstellen

Bevor du mit der Erstellung einer Flask-Anwendung beginnst, stelle sicher, dass du dich in deiner virtuellen Python-Umgebung befindest.

Erstelle eine neue Python-Datei„myflask.py“ mit deinem bevorzugten Editor. In diesem Beispiel verwenden wir den Editor nano.

nano myflask.py

Füge nun das folgende Skript in die Datei ein.

# myflask.py
from flask import Flask, render_template  # importing the render_template function

app = Flask(__name__)
# route to index page
@app.route(„/“)
def hello():
return render_template(‚index.html‘)

if __name__ == „__main__“:
app.run(host=’0.0.0.0′)

Speichere die Datei und beende den Editor, wenn du fertig bist.

Als Nächstes legst du ein neues Verzeichnis„templates“ für deine statischen Dateien an und erstellst darin eine neue index.html-Datei.

mkdir -p templates
nano templates/index.html

Füge das folgende HTML-Skript in die Datei ein.

<html>
    <body>
        <h1><center>Hello Flask - Rocky Linux!</center></h1>
    </body>
</html>

Speichere die Datei und beende den Editor, wenn du fertig bist.

Führe nun das Python-Flask-Skript „myflask.py“ mit dem unten stehenden Befehl aus. Dadurch wird deine Flask-Anwendung im Entwicklungsmodus mit der Server-IP-Adresse und dem Standard-Port 5000 ausgeführt.

python3 myflask.py

Unten siehst du eine ähnliche Ausgabe, die du erhalten wirst.

Als Nächstes öffnest du ein anderes Terminal und führst den unten stehenden curl-Befehl aus, um auf deine Flask-Anwendung zuzugreifen. Du wirst das Skript der Datei „index.html“ sehen, die du erstellt hast.

curl localhost:5000

Drücke nun„Strg+c„, um deine Flask-Anwendung zu beenden.

Gunicorn und Supervisord einrichten

In diesem Schritt richtest du deine Flask-Anwendung mit Gunicorn und Supervisord ein. So kannst du deine Python-Anwendung über den Supervisord-Prozess verwalten und kontrollieren.

Erstelle eine neue Python-Datei„uwsgi.py“ in demselben Verzeichnis wie deine Flask-Anwendung. In diesem Beispiel sollte das Verzeichnis„/var/www/myflask“ sein.

nano wsgi.py

Füge das folgende Python-Skript in die Datei ein.

# import myflask Flask application
from myflask import app

if __name__ == „__main__“:
app.run(debug=True)

Speichere die Datei und beende den Editor, wenn du fertig bist.

Führe nun den folgenden gunicorn-Befehl aus, um die Flask-Anwendung zu starten und die Konfigurationen von Gunicorn zu überprüfen. Die Anwendung sollte jetzt unter Gunicron mit Port 8000 laufen.

gunicorn -w 4 --bind 0.0.0.0:8000 wsgi:app

Unten siehst du die Ausgabe des gunicorn-Befehls.

Als Nächstes öffnest du deinen Webbrowser und rufst die IP-Adresse des Servers auf, gefolgt von Port 8000 (d.h.: http://192.168.5.100:8000/). Du solltest die Seite index.html deiner Flask-Anwendung sehen.

Zu diesem Zeitpunkt läuft deine Flask-Anwendung mit Gunicorn ohne Fehler. Du kannst jetzt zu deinem Terminal zurückkehren und„Strg+c“ drücken, um den Gunicorn-Prozess zu beenden und mit der Konfiguration des Supervisord-Prozessmanagers zu beginnen.

Erstelle mit dem folgenden nano-Befehl eine neue Supervisord-INI-Datei für die Konfiguration der Flask-Anwendung „/etc/supervisord.d/flaskapp.ini“. Die Konfiguration sollte im Verzeichnis„/etc/supervisord.d“ gespeichert werden.

sudo nano /etc/supervisord.d/flaskapp.ini

Füge die folgende Konfiguration in die Datei ein. Achte darauf, dass du den Detailpfad deiner Anwendungen, den Benutzer und die Gruppe sowie den Log-Pfad änderst.

Mit dieser Konfiguration wird deine Flask-Anwendung unter dem UNIX-Socket laufen, der von Gunicorn erstellt wird. Dieser Unix-Socket wird auch für die Interaktion mit dem Nginx-Reverse-Proxy verwendet.

[program:myflask] 
command=/bin/bash -c 'source /var/www/myflask/myenv/bin/activate; gunicorn -w 3 --bind unix:/var/www/myflask/ipc.sock wsgi:app'
directory=/var/www/myflask
user=alice
group=www-data
autostart=true 
autorestart=true 
stdout_logfile=/var/www/myflask/myflask.log 
stderr_logfile=/var/www/myflask/error.log

Speichere die Datei und schließe den Editor, wenn du fertig bist.

Führe nun den folgenden systemctl-Befehl aus, um den Supervisord-Dienst neu zu starten und die neuen Änderungen zu übernehmen. Überprüfe dann den Supervisord-Status und stelle sicher, dass der Dienst läuft.

sudo systemctl restart supervisord
sudo systemctl status supervisord

Auf dem Screenshot unten siehst du, dass Supervisord mit einer neuen zusätzlichen Konfiguration für die Flask-Anwendung läuft.

Abschließend kannst du den Prozess deiner Flask-Anwendung mit dem Befehl supervisorctl überprüfen. Du solltest sehen, dass es einen Prozess namens myflask mit dem Status OK gibt.

sudo supervisorctl status

Nginx Reverse Proxy einrichten

In diesem Schritt lernst du, wie du Nginx als Reverse Proxy für die Flask-Anwendung einrichtest, die unter dem Supervisord-Prozessmanager läuft. Du erstellst einen neuen Nginx Server Block für den Reverse Proxy und verwendest den lokalen Domainnamen für die Flask-Anwendung.

Erstelle eine neue Nginx Server Block Konfiguration „/etc/nginx/conf.d/flaskapp.conf“ mit dem folgenden nano Editor.

sudo nano /etc/nginx/conf.d/flaskapp.conf

Füge die folgende Konfiguration in die Datei ein. Achte darauf, dass du den Domänennamen www.myflask.local durch deine lokale Entwicklungsdomäne ersetzt.

server {
    listen 80;
    server_name www.myflask.local;
location / {
include uwsgi_params;
proxy_pass http://unix:/var/www/myflask/ipc.sock;
}
}

Speichere die Datei und beende den Editor, wenn du fertig bist.

Als Nächstes überprüfst du die Nginx-Konfiguration, um sicherzustellen, dass du die richtige Konfiguration hast. Starte dann den Nginx-Dienst neu, um die Änderungen zu übernehmen.

sudo nginx -t
sudo systemctl restart nginx

Jetzt ist deine Flask-Anwendung über den Nginx-Reverse-Proxy, der auf dem Standard-HTTP-Port läuft, erreichbar.

Bearbeite nun auf deinem lokalen Rechner die Datei /etc/hosts mit dem nano-Editor.

sudo nano /etc/hosts

Lege die IP-Adresse des Ubuntu-Rechners mit dem Domänennamen „www.myflask.local“ fest (siehe unten).

192.168.5.28 www.myflask.local

Speichere und schließe die Datei.

Öffne nun deinen Webbrowser und gib den Domainnamen des Flask-Projekts (z.B. http://www.myflask.local) in die Adressleiste ein. Du solltest nun die Index-Seite deines Python-Flask-Projekts sehen.

Fazit

Herzlichen Glückwunsch! Du hast das Webframework Python Flask mit Gunicorn und Nginx erfolgreich auf dem Rocky Linux Server installiert. Außerdem hast du gelernt, wie du das erste Python Flask-Projekt erstellst, eine virtuelle Python-Umgebung einrichtest und die Supervisord-Prozessverwaltung für das Flask-Projekt einrichtest.