Flask ist ein sehr einfaches, aber äußerst flexibles Framework, das Ihre Anwendungen mit Funktionalität ausstatten soll, ohne zu restriktiv in Bezug auf Struktur und Design zu sein. Sie können den in diesem Artikel beschriebenen allgemeinen Stack verwenden, um die von Ihnen entworfenen Flask-Anwendungen bereitzustellen.
In diesem Artikel richten wir eine einfache Python-Anwendung mit dem Mikro-Framework Flask auf Ubuntu 18.04 ein.
Der Großteil dieses Artikels befasst sich mit der Einrichtung des Gunicorn-Anwendungsservers zum Starten der Anwendung und mit Nginx als Front-End-Reverse-Proxy.
Voraussetzungen
Bevor Sie mit diesem Artikel beginnen, sollten Sie einen Nicht-Root-Benutzer auf Ihrem Server konfiguriert haben. Dieser Benutzer muss über sudo-Berechtigungen verfügen, damit er Verwaltungsfunktionen ausführen kann.
Erstellen Sie einen Nicht-Root-Benutzer mit konfigurierten sudo-Berechtigungen:
1- Einloggen als Root
2- Erstellen eines neuen Benutzers
# adduser bobby3- 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 bobbyInstallieren Sie die Komponenten aus den Ubuntu-Repositories
Der erste Schritt besteht darin, alle Teile zu installieren, die wir aus den Repositories benötigen. Wir werden pip, den Paketmanager von Python 3, installieren, um unsere Python 3-Komponenten zu installieren und zu verwalten. Wir werden auch die Python 3-Entwicklungsdateien erhalten, die zum Erstellen einiger der Gunicorn-Komponenten erforderlich sind. Wir werden jetzt auch Nginx installieren.
Aktualisieren Sie Ihren lokalen Paketindex und installieren Sie dann die Pakete. Die spezifischen Pakete, die Sie benötigen, hängen von der Version von Python ab, die Sie für Ihr Projekt verwenden.
Geben Sie beim Installieren von Python 3 Folgendes ein:
$ sudo apt-get update
$ sudo apt-get install python3-pip python3-dev nginxErstellen Sie eine virtuelle Python 3-Umgebung
Als Nächstes richten wir eine virtuelle Umgebung ein, um unsere Flask-Anwendung von den anderen Python-Dateien auf dem System zu isolieren.
Beginnen Sie mit der Installation des virtualenv-Pakets mit pip.
Wenn Sie Python 3 verwenden, geben Sie Folgendes ein:
sudo pip3 install virtualenvJetzt können wir ein übergeordnetes Verzeichnis für unser Flask-Projekt erstellen. Wechseln Sie in das Verzeichnis, nachdem Sie es erstellt haben:
mkdir ~/flaskproject
cd ~/flaskprojectWir können eine virtuelle Umgebung erstellen, um die Python-Anforderungen unseres Flask-Projekts zu speichern, indem wir Folgendes eingeben:
virtualenv flaskprojectenv
Dadurch wird eine lokale Kopie von Python installiert und in ein Verzeichnis mit dem Namen Flaskprojectenv in Ihrem Projektverzeichnis gepipt.
Bevor wir Anwendungen in der virtuellen Umgebung installieren, müssen wir sie aktivieren. Geben Sie dazu Folgendes ein:
source flaskprojectenv/bin/activate
Ihre Eingabeaufforderung ändert sich, um anzuzeigen, dass Sie jetzt in der virtuellen Umgebung arbeiten. Es sieht in etwa so aus (flaskprojectenv)user@host:~/flaskproject$ .
Richten Sie eine Flask-Anwendung ein
Jetzt, da Sie sich in Ihrer virtuellen Umgebung befinden, können wir Flask und Gunicorn installieren und mit dem Entwerfen unserer Anwendung beginnen:
Installieren Sie Flask und Gunicorn
Wir können die lokale Instanz von pip verwenden um Flask und Gunicorn zu installieren. Geben Sie die folgenden Befehle ein, um diese beiden Komponenten abzurufen:
Hinweis: Unabhängig davon, welche Version von Python Sie verwenden, sollten Sie bei aktivierter virtueller Umgebung den pip verwenden Befehl (nicht pip3 ).
(flaskprojectenv) $ pip install gunicorn flaskBeispiel-App erstellen
Jetzt, da uns Flask zur Verfügung steht, können wir eine einfache Anwendung erstellen. Flask ist ein Mikro-Framework. Es enthält nicht viele der Tools, die Frameworks mit mehr Funktionen bieten könnten, und existiert hauptsächlich als Modul, das Sie in Ihre Projekte importieren können, um Sie bei der Initialisierung einer Webanwendung zu unterstützen.
Auch wenn Ihre Anwendung komplexer sein könnte, erstellen wir unsere Flask-App in einer einzigen Datei, die wir "flaskproject.py" nennen:
(flaskprojectenv) $ nano ~/flaskproject/flaskproject.pyIn dieser Datei platzieren wir unseren Anwendungscode. Grundsätzlich müssen wir Flask importieren und ein Flask-Objekt instanziieren. Wir können dies verwenden, um die Funktionen zu definieren, die ausgeführt werden sollen, wenn eine bestimmte Route angefordert wird:
~/flaskproject/flaskproject.py
from flask import Flask
app = Flask(__name__)
@app.route("/")
def greeting():
return "<h1 style='color:green'>Hello World!</h1>"
if __name__ == "__main__":
app.run(host='0.0.0.0')Dies definiert im Wesentlichen, welche Inhalte angezeigt werden, wenn auf die Stammdomäne zugegriffen wird. Speichern und schließen Sie die Datei, wenn Sie fertig sind.
Wenn Sie die Anleitung zur Ersteinrichtung des Servers befolgt haben, sollte eine UFW-Firewall aktiviert sein. Um unsere Anwendung zu testen, müssen wir den Zugriff auf Port 5000 zulassen.
Öffnen Sie Port 5000, indem Sie Folgendes eingeben:
(flaskprojectenv) $ sudo ufw allow 5000Jetzt können Sie Ihre Flask-App testen, indem Sie Folgendes eingeben:
(flaskprojectenv) $ python flaskproject.py
Rufen Sie den Domänennamen oder die IP-Adresse Ihres Servers gefolgt von :5000 auf in Ihrem Webbrowser:
http://server_domain_or_IP:5000
Sie sollten so etwas sehen:
Wenn Sie fertig sind, drücken Sie CTRL-C in Ihrem Terminalfenster ein paar Mal, um den Flask-Entwicklungsserver zu stoppen.
Erstellen Sie den WSGI-Einstiegspunkt
Als Nächstes erstellen wir eine Datei, die als Einstiegspunkt für unsere Anwendung dient. Dadurch wird unserem Gunicorn-Server mitgeteilt, wie er mit der Anwendung interagieren soll.
Wir nennen die Datei wsgi.py :
(flaskprojectenv) $ nano ~/flaskproject/wsgi.pyDie Datei ist unglaublich einfach, wir können einfach die Flask-Instanz aus unserer Anwendung importieren und dann ausführen:
~/flaskproject/wsgi.py
from flaskproject import app
if __name__ == "__main__":
app.run()Speichern und schließen Sie die Datei, wenn Sie fertig sind.
Testen der Fähigkeit von Gunicorn, dem Projekt zu dienen
Bevor wir fortfahren, sollten wir überprüfen, ob Gunicorn es richtig kann. Wir können dies tun, indem wir ihm einfach den Namen unseres Einstiegspunkts übergeben. Diese wird aus dem Namen des Moduls (abzüglich der .py Nebenstelle, wie üblich) plus den Namen des Anrufers innerhalb der Anwendung. In unserem Fall wäre dies wsgi:app .
Wir geben auch die Schnittstelle und den Port an, an die gebunden werden soll, damit es auf einer öffentlich verfügbaren Schnittstelle gestartet wird:
(flaskprojectenv) $ cd ~/flaskproject
(flaskprojectenv) $ gunicorn --bind 0.0.0.0:5000 wsgi:appRufen Sie in Ihrem Webbrowser erneut den Domänennamen oder die IP-Adresse Ihres Servers mit angehängtem :5000 auf:
http://server_domain_or_IP:5000
Sie sollten die Ausgabe Ihrer Anwendung erneut sehen:
Wenn Sie bestätigt haben, dass es richtig funktioniert, drücken Sie CTRL-C in Ihrem Terminalfenster.
Wir sind jetzt mit unserer virtuellen Umgebung fertig, also können wir sie deaktivieren:
(flaskprojectenv) $ deactivateAlle Python-Befehle verwenden jetzt wieder die Python-Umgebung des Systems.
Erstellen Sie eine systemd Unit-Datei
Das nächste Stück, um das wir uns kümmern müssen, ist die systemd-Service-Unit-Datei. Das Erstellen einer systemd-Unit-Datei ermöglicht es dem Init-System von Ubuntu, Gunicorn automatisch zu starten und unsere Flask-Anwendung bereitzustellen, wenn der Server hochfährt.
Erstellen Sie eine Unit-Datei mit der Endung .service innerhalb von /etc/systemd/system Verzeichnis zu beginnen:
$ sudo nano /etc/systemd/system/flaskproject.service
Darin beginnen wir mit [Unit] -Abschnitt, der verwendet wird, um Metadaten und Abhängigkeiten anzugeben. Wir werden hier eine Beschreibung unseres Dienstes einfügen und dem init mitteilen System, dies erst nach Erreichen des Vernetzungsziels zu starten
Als nächstes öffnen wir den [Service] Sektion. Wir geben den Benutzer und die Gruppe an, unter denen der Prozess ausgeführt werden soll. 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 einfach mit den Gunicorn-Prozessen kommunizieren kann.
Dann ordnen wir das Arbeitsverzeichnis zu und setzen die Umgebungsvariable PATH so, dass die Datei init System weiß, wo sich unsere ausführbaren Dateien für den Prozess befinden (innerhalb unserer virtuellen Umgebung). Wir geben dann den Befehl zum Starten des Dienstes an. Systemd erfordert, dass wir den vollständigen Pfad zur ausführbaren Gunicorn-Datei angeben, die in unserer virtuellen Umgebung installiert ist.
Wir werden es anweisen, 3 Worker-Prozesse zu starten (passen Sie dies nach Bedarf an). Wir werden es auch anweisen, eine Unix-Socket-Datei namens flaskproject.sock in unserem Projektverzeichnis zu erstellen und zu binden . Wir setzen einen umask-Wert von 007 sodass die Socket-Datei erstellt wird, die dem Eigentümer und der Gruppe Zugriff gewährt, während der andere Zugriff eingeschränkt wird. Schließlich müssen wir den Dateinamen des WSGI-Einstiegspunkts und den darin aufrufbaren Python übergeben.
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/flaskproject.service
[Unit]
Description=Gunicorn instance to serve flaskproject
After=network.target
[Service]
User=bobby
Group=www-data
WorkingDirectory=/home/bobby/flaskproject
Environment="PATH=/home/bobby/flaskproject/flaskprojectenv/bin"
ExecStart=/home/bobby/flaskproject/flaskprojectenv/bin/gunicorn --workers 3 --bind unix:flaskproject.sock -m 007 wsgi:app
[Install]
WantedBy=multi-user.targetDamit ist unsere systemd-Servicedatei vollständig. Jetzt speichern und schließen.
Wir können jetzt den von uns erstellten Gunicorn-Dienst starten und ihn so aktivieren, dass er beim Booten startet:
$ sudo systemctl start flaskproject
$ sudo systemctl enable flaskprojectKonfigurieren von Nginx für Proxy-Anfragen
Unser Gunicorn-Anwendungsserver sollte jetzt betriebsbereit sein und auf Anfragen für die Socket-Datei im Projektverzeichnis warten. Wir müssen Nginx konfigurieren, um Webanfragen an diesen Socket weiterzuleiten, indem wir einige kleine Ergänzungen zu seiner Konfigurationsdatei vornehmen.
Beginnen Sie mit der Erstellung einer neuen Serverblock-Konfigurationsdatei in sites-available von Nginx Verzeichnis. Wir nennen dieses Flaskproject einfach, um es mit dem Rest des Artikels in Einklang zu bringen:
$ sudo nano /etc/nginx/sites-available/flaskproject
Öffnen Sie einen server blockieren und Nginx anweisen, auf dem Standardport 80 zu lauschen. Wir müssen es auch anweisen, diesen Block für Anfragen nach dem Domainnamen oder der IP-Adresse unseres Servers zu verwenden.
Das einzige, was wir noch hinzufügen müssen, ist ein location Block, der jeder Anfrage entspricht. In diesen Block fügen wir die proxy_params ein Datei, die einige allgemeine Proxying-Parameter angibt, die festgelegt werden müssen. Anschließend leiten wir die Anfragen an den Socket weiter, den wir mit proxy_pass definiert haben Direktive:
/etc/nginx/sites-available/flaskproject
server {
listen 80;
server_name server_domain_or_IP;
location / {
include proxy_params;
proxy_pass http://unix:/home/bobby/flaskproject/flaskproject.sock;
}
}Das ist eigentlich alles, was wir brauchen, um unsere Anwendung zu bedienen. Speichern und schließen Sie die Datei, wenn Sie fertig sind.
Um den Nginx server zu aktivieren Block-Konfiguration, die wir gerade erstellt haben, verknüpfen Sie die Datei mit sites-enabled Verzeichnis:
$ sudo ln -s /etc/nginx/sites-available/flaskproject /etc/nginx/sites-enabledMit der Datei in diesem Verzeichnis können wir auf Syntaxfehler testen, indem wir Folgendes eingeben:
$ sudo nginx -tWenn dies ohne Anzeige von Problemen zurückkehrt, können wir den Nginx-Prozess neu starten, um unsere neue Konfiguration zu lesen:
$ sudo systemctl restart nginxDas letzte, was wir tun müssen, ist, unsere Firewall erneut anzupassen. Wir benötigen keinen Zugriff mehr über Port 5000, daher können wir diese Regel entfernen. Wir können dann den Zugriff auf den Nginx-Server erlauben:
$ sudo ufw delete allow 5000
$ sudo ufw allow 'Nginx Full'Sie sollten jetzt den Domänennamen oder die IP-Adresse Ihres Servers in Ihrem Webbrowser aufrufen können:
http://server_domain_or_IPSie sollten die Ausgabe Ihrer Anwendung sehen:
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 Passwörter, im Klartext über das Netzwerk gesendet werden. Der einfachste Weg, ein SSL-Zertifikat zum Sichern Ihres Datenverkehrs zu erhalten, ist die Verwendung von Let's Encrypt.
Lesen Sie auch
- So installieren Sie SSL-Zertifikate von Let's Encrypt auf Ubuntu 18.04
- So richten Sie die Django-Entwicklungsumgebung unter Ubuntu 18.04 ein
- So installieren Sie LEMP auf Ubuntu 18.04
Fazit: In diesem Artikel haben wir eine einfache Flask-Anwendung in einer virtuellen Python-Umgebung erstellt. Wir erstellen einen WSGI-Einstiegspunkt, damit jeder WSGI-fähige Anwendungsserver eine Schnittstelle damit herstellen kann, und konfigurieren dann den Gunicorn-Anwendungsserver, um diese Funktion bereitzustellen. Anschließend haben wir eine systemd-Unit-Datei erstellt, um den Anwendungsserver beim Booten automatisch zu starten. Wir haben einen Nginx-Serverblock erstellt, der den Datenverkehr des Webclients an den Anwendungsserver weiterleitet und externe Anfragen weiterleitet.