TOC

Bereitstellen von Falcon-Webanwendungen mit Gunicorn und Nginx unter Ubuntu 16.04

Einführung

Falcon ist ein minimales Python-Framework zum Erstellen von Webanwendungen. Es eignet sich gut zum Erstellen von APIs, die dem Architekturstil REST folgen. Es handelt sich um ein leistungsfähiges Framework auf niedriger Ebene, das versucht, so wenig wie möglich zu tun, ohne die Entwicklungsgeschwindigkeit zu beeinträchtigen.

In diesem Lernprogramm erstellen Sie eine Falcon-Webanwendung und stellen sie bereit. Falcon ist ein WSGI -Framework, daher installieren und verwenden Sie Gunicorn, einen WSGI-Anwendungsserver, um die App bereitzustellen . Anschließend erstellen Sie eine produktionsbereite Umgebung mit Nginx als Reverse-Proxy-Server, um eingehende Anforderungen zu verarbeiten, bevor sie Gunicorn erreichen.

Voraussetzungen

Um dieses Tutorial abzuschließen, benötigen Sie:

Schritt 1 - Erstellen der virtuellen Python-Umgebung

Bevor wir uns mit dem Schreiben von Code oder dem Einrichten von Diensten befassen, erstellen wir eine virtuelle Python-Umgebung für unsere Anwendung auf dem Server.

Stellen Sie als Nicht-Root-Benutzer eine Verbindung zu Ihrem Server her:

ssh @

Falcon funktioniert sowohl mit Python 2.x als auch mit Python 3.x, aber wir werden die neueste Version von Python verwenden, die in Ubuntu 16.04 verfügbar ist, nämlich Python 3.5.

Wir werden pip und virtualenv verwenden, um unsere Falcon-Anwendung einzurichten. Weitere Informationen zu diesen Tools finden Sie in unserem Lernprogramm unter common Python tools .

Installieren Sie zunächst virtualenv:

sudo apt-get install virtualenv

Erstellen Sie als Nächstes ein Verzeichnis, das den Quellcode Ihrer Anwendung und die virtuelle Umgebung enthält, und wechseln Sie in dieses Verzeichnis:

mkdir
cd

Dann erstelle die virtuelle Umgebung:

virtualenv venv -p /usr/bin/python3

Dieser Befehl erstellt eine virtuelle Umgebung im Verzeichnis "+ venv ". Das ` -p +` Flag gibt an, welche Version von Python in der virtuellen Umgebung verwendet wird.

Sie sehen diese Ausgabe:

OutputAlready using interpreter /usr/bin/python3
Using base prefix '/usr'
New python executable in /home/sammy/falcon_app/venv/bin/python3
Also creating executable in /home/sammy/falcon_app/venv/bin/python
Installing setuptools, pkg_resources, pip, wheel...done.

Aktivieren Sie nun die virtuelle Umgebung:

. venv/bin/activate

Nachdem Sie Ihre virtuelle Python-Umgebung eingerichtet haben, installieren Sie die erforderlichen Python-Pakete.

Schritt 2 - Installation von Falcon und Gunicorn mit pip

Wir müssen das + falcon + Paket installieren und da wir Gunicorn verwenden, um unsere App zu bedienen, müssen wir das auch installieren. Beide sind über "+ pip +" verfügbar.

Sie können Falcon auf zwei Arten installieren. Falcon hat eine Binärdatei, die Sie mit + pip install falcon + installieren können, aber Falcon kann einen zusätzlichen Geschwindigkeitsschub erhalten, wenn es mit Cython kompiliert wird. Geben Sie die folgenden Befehle ein, um Cython zu installieren, und informieren Sie Falcon anschließend, um es zu erkennen und sich selbst mit dem C-Compiler des Systems zu kompilieren:

sudo apt-get install build-essential python3-dev
pip install cython
pip install --no-binary :all: falcon

Als nächstes installieren Sie Gunicorn:

pip install gunicorn

Fahren wir mit dem Schreiben unserer einfachen Falcon-Anwendung fort.

Schritt 3 - Schreiben einer einfachen Webanwendung mit Falcon

Erstellen wir eine einfache Einzeldatei-Falcon-Anwendung. Erstellen Sie die Datei "+ main.py " im Verzeichnis " falcon_app +":

nano main.py

Füllen Sie die Datei mit dem folgenden Inhalt, wodurch eine Falcon-Anwendung erstellt wird, die eine einfache Testnachricht anzeigt, wenn Benutzer die Route "+ / test +" besuchen:

main.py

import falcon

class TestResource(object):
   def on_get(self, req, res):
       """Handles all GET requests."""
       res.status = falcon.HTTP_200  # This is the default status
       res.body = ('This is me, Falcon, serving a resource!')

# Create the Falcon application object
app = falcon.API()

# Instantiate the TestResource class
test_resource = TestResource()

# Add a route to serve the resource
app.add_route('/test', test_resource)

In dieser Datei erstellen wir eine Klasse mit dem Namen "+ TestResource ". Diese Klasse enthält eine " on_get " - Methode, die die Antwort definiert, die wir senden möchten. Dann erstellen wir Instanzen der Falcon API und ` TestResource `. Dann fügen wir der API die Route " / test " hinzu und hängen das Ressourcenobjekt " test_resource +" daran an.

Immer wenn eine "+ GET " - Anfrage an die " / test " - URL gesendet wird, wird die " on_get () " - Methode von " TestResource " aufgerufen. Der Antwortstatus und der Body werden mit den Variablen " res.status " und " res.body +" festgelegt.

Speichern Sie die Datei und schließen Sie Ihren Editor. Testen wir die Anwendung.

Schritt 4 - Servieren einer Falcon-Anwendung mit Gunicorn

Bevor wir unsere Anwendung mit Nginx produktionsbereit machen, stellen wir sicher, dass unsere Anwendung funktioniert, indem wir sie mit Gunicorn bereitstellen.

Stellen Sie sicher, dass Sie sich im Verzeichnis "+ falcon_app +" befinden. Starten Sie Gunicorn mit folgendem Befehl:

gunicorn -b :5000 main:app --reload

Dies startet Gunicorn und bedient unsere Webanwendung an ++ auf Port + 5000 +, wie Sie an der Ausgabe sehen können:

Output[2016-11-14 16:33:41 +0000] [9428] [INFO] Starting gunicorn 19.6.0
[2016-11-14 16:33:41 +0000] [9428] [INFO] Listening at:  (9428)
[2016-11-14 16:33:41 +0000] [9428] [INFO] Using worker: sync
[2016-11-14 16:33:41 +0000] [9431] [INFO] Booting worker with pid: 9431

Sie können jede beliebige Portnummer verwenden, stellen Sie jedoch sicher, dass sie über "+ 1024 +" liegt und von keinem anderen Programm verwendet wird.

Die Option "+ main: app " weist Gunicorn an, das Anwendungsobjekt " app " aufzurufen, das in der Datei " main.py +" verfügbar ist.

Gunicorn bietet einen optionalen "+ - reload +" - Schalter, der Gunicorn anweist, Codeänderungen im laufenden Betrieb zu erkennen. Auf diese Weise können Sie Ihren Code ändern, ohne Gunicorn neu starten zu müssen.

Testen Sie Ihre Anwendung, indem Sie Ihren Webbrowser auf Ihrem lokalen Computer öffnen und "+ http: //: 5000 / test +" in Ihrem Browser aufrufen. Die folgende Ausgabe Ihrer Webanwendung wird angezeigt:

Bild: https://assets.digitalocean.com/articles/falcon_gunicorn_nginx_1604/drw9BfS.png [Antwort von Falcon]

Stoppen Sie Gunicorn mit + CTRL + C +. Lassen Sie uns dies auf produktionsbereite Weise einrichten.

Schritt 5 - Verwenden von Nginx für Proxy-Anfragen an Gunicorn

Wir werden Nginx so einrichten und konfigurieren, dass alle Webanfragen an Gunicorn weitergeleitet werden, anstatt dass Gunicorn Anfragen von außen direkt bearbeitet. Auf diese Weise werden alle Anforderungen Ihrer Webanwendung zuerst von Nginx erkannt und dann an den Anwendungsserver weitergeleitet.

Installieren Sie zunächst Nginx, indem Sie den folgenden Befehl ausführen:

sudo apt-get install nginx

Als nächstes erstellen Sie eine neue Konfigurationsdatei mit dem Namen "+ falcon_app.conf " im Verzeichnis " / etc / nginx / sites-available +". Diese Datei konfiguriert Nginx so, dass alle Anfragen, die an die IP-Adresse Ihres Servers gesendet werden, an den Gunicorn-Server unserer Falcon-Anwendung weitergeleitet werden.

sudo nano /etc/nginx/sites-available/falcon_app.conf

Fügen Sie der Datei den folgenden Inhalt hinzu:

/etc/nginx/sites-available/falcon_app.conf

server {
   listen 80;
   server_name ;

   location / {
       include proxy_params;
       proxy_pass http://localhost:5000;
   }
}

Diese Konfiguration weist Nginx an, auf den Port "+ 80 " zu lauschen und alle HTTP-Anforderungen an " http: // localhost: 5000 +" zu übermitteln, wo Gunicorn lauscht.

Aktivieren Sie diese Konfiguration, indem Sie einen symbolischen Link zu dieser Datei im Verzeichnis "+ / etc / nginx / sites-enabled +" erstellen:

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

Deaktivieren Sie dann die Standard-Nginx-Konfigurationsdatei, indem Sie den Symlink aus dem Verzeichnis "+ / etc / nginx / sites-enabled +" entfernen:

sudo rm /etc/nginx/sites-enabled/default

Stellen Sie sicher, dass in keiner Ihrer Nginx-Dateien Syntaxfehler enthalten sind:

sudo nginx -t

Diese Meldung wird angezeigt, wenn Sie eine funktionierende Konfiguration haben:

Outputnginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Wenn Sie Fehler sehen, beheben Sie diese und testen Sie sie erneut.

Starten Sie Nginx neu, damit die neue Konfiguration wirksam wird.

sudo systemctl restart nginx

Starten Sie nun Gunicorn erneut, ändern Sie jedoch die Abhöradresse von "+ 0.0.0.0 " in " localhost +", um den öffentlichen Zugriff auf Gunicorn zu verhindern:

gunicorn -b  main:app --reload

Ermöglichen Sie den Zugriff auf den Port "+ 80 +" über die Firewall des Servers, wenn Sie diese aktiviert haben:

sudo ufw allow 80

Testen Sie die App, indem Sie "+ http: /// test +" aufrufen, und Sie sehen dieselbe Ausgabe, die Sie zuvor gesehen haben.

Beachten Sie, dass Sie die Portnummer in der URL nicht mehr benötigen, da Ihre Anforderungen jetzt Nginx durchlaufen, das auf Port + 80 +, dem Standard-HTTP-Port, ausgeführt wird. In Ihrem Browser wird folgende Ausgabe angezeigt:

image: https: //assets.digitalocean.com/articles/falcon_gunicorn_nginx_1604/6pKlicT.png [Der Falke ist jetzt durch Nginx vertreten]

Stoppen Sie den App-Server, indem Sie die Tastenkombination "+ STRG + C +" drücken. Lassen Sie uns unsere Falcon-Anwendung so konfigurieren, dass sie wie unsere anderen Dienste automatisch im Hintergrund gestartet wird.

Schritt 7 - Gunicorn mit Systemd verwalten

Wir sollten sicherstellen, dass unsere Anwendung jedes Mal automatisch startet, wenn unser Server hochfährt, genau wie Nginx. Wenn unser Server versehentlich neu gestartet wurde oder aus irgendeinem Grund neu gestartet werden musste, sollten wir Gunicorn nicht manuell starten müssen.

Um dies zu konfigurieren, erstellen wir eine Systemd-Unit-Datei für unsere Gunicorn-Anwendung, damit wir sie verwalten können.

Zunächst erstellen wir eine Datei für unsere Anwendung im Verzeichnis "+ / etc / systemd / system" mit der Erweiterung "+ .service":

sudo nano /etc/systemd/system/

Eine Unit-Datei besteht aus Abschnitten. Der Abschnitt "+ [Einheit] +" wird verwendet, um die Metadaten und Abhängigkeiten unseres Dienstes anzugeben, einschließlich einer Beschreibung unseres Dienstes und des Zeitpunkts, zu dem unser Dienst gestartet werden soll.

Fügen Sie diese Konfiguration zur Datei hinzu:

/etc/systemd/system/falcon_app.service

[Unit]
Description=Gunicorn instance to serve the falcon application
After=network.target

Wir legen fest, dass der Dienst gestartet werden soll, nachdem das Netzwerkziel erreicht wurde. Mit anderen Worten, wir starten diesen Dienst erst, nachdem die Netzwerkdienste bereit sind.

Nach dem Abschnitt "+ [Einheit] " definieren wir den Abschnitt " [Dienst] +", in dem wir angeben, wie der Dienst gestartet werden soll. Fügen Sie dies zur Konfigurationsdatei hinzu:

/etc/systemd/system/falcon_app.service

[Service]
User=
Group=
PIDFile=
Environment="PATH=/home/sammy//venv/bin"
WorkingDirectory=/home/sammy/
ExecStart=/home///venv/bin/gunicorn --workers 3 -b
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s TERM $MAINPID

Wir definieren zuerst den Benutzer und die Gruppe, unter denen der Dienst ausgeführt wird. Anschließend definieren wir eine Datei zum Speichern der PID (Prozess-ID) des Dienstes. Diese PID wird zum Stoppen oder erneuten Laden des Dienstes verwendet.

Außerdem geben wir die virtuelle Python-Umgebung an, das Arbeitsverzeichnis der Anwendung. und den auszuführenden Befehl zum Starten der Anwendung. Wir weisen den Befehl zum Starten von Gunicorn der Variablen + ExecStart + zu. Das + - Arbeiter + Flag wird verwendet, um die Anzahl der Arbeiter zu definieren, mit denen Gunicorn beginnen soll. In den Gunicorn-Dokumenten wird vorgeschlagen, die Anzahl der Worker auf "+ 2n + 1 " festzulegen, wobei " n " die Anzahl der CPU-Kerne ist. Unter der Annahme, dass Ihr Server einen einzelnen CPU-Kern hat, erhalten wir die Nummer " 3 +".

Die Variablen + ExecReload + und + ExecStop + definieren, wie der Dienst gestartet und gestoppt werden soll.

Schließlich fügen wir den Abschnitt "+ [Install] +" hinzu, der so aussieht:

/etc/systemd/system/falcon_app.service

[Install]
WantedBy=multi-user.target

Im Abschnitt "+ Install " können Sie den Dienst aktivieren und deaktivieren. Die Direktive " WantedBy " erstellt ein Verzeichnis mit dem Namen " multi-user.target " in " / etc / systemd / system +" und ein symbolischer Link dieser Datei wird dort erstellt. Durch Deaktivieren dieses Dienstes wird diese Datei aus dem Verzeichnis entfernt.

Speichern Sie die Datei, schließen Sie den Editor und starten Sie den neuen Dienst:

sudo systemctl start

Aktivieren Sie dann diesen Dienst, damit Gunicorn bei jedem Start des Servers die Webanwendung bedient:

sudo systemctl enable

Richten Sie Ihren Browser erneut auf "+ http: /// test", um Ihre Anwendung anzuzeigen. Sowohl Nginx als auch Gunicorn laufen im Hintergrund. Wenn Sie Ihre Falcon-Anwendung aktualisieren müssen, starten Sie den Dienst + falcon_app + neu:

sudo systemctl restart

Weitere Informationen zu Unit-Dateien finden Sie im Tutorial Understanding Systemd Units and Unit files.

Fazit

In diesem Handbuch haben Sie Ihre erste Falcon-Webanwendung konfiguriert und bereitgestellt. Sie haben die Python-Umgebung eingerichtet und Ihren Anwendungscode auf dem Server geschrieben. Anschließend haben Sie die Webanwendung mit Gunicorn bereitgestellt. Dann haben Sie Nginx so konfiguriert, dass es Webanforderungen an unsere Gunicorn-Anwendung weiterleitet. Schließlich haben Sie eine Systemd Unit-Datei geschrieben und den Dienst aktiviert, sodass Ihre Webanwendung beim Starten des Servers gestartet wird.

Wenn Sie Ihre eigenen Apps in Betrieb nehmen, möchten Sie auf sie mit einem Hostnamen anstelle der IP-Adresse zugreifen. Schauen Sie unter Einrichten eines Hostnamens mit DigitalOcean nach, um auf Ihre Domain zu verweisen Name auf Ihrem Server.

Related