TOC

Bereitstellen von Web2py-Python-Anwendungen mit uWSGI und Nginx unter CentOS 7

Einführung

Das web2py-Framework ist ein leistungsstarkes und benutzerfreundliches Tool für die schnelle Entwicklung von Python-Webanwendungen mit vollem Funktionsumfang. Mit web2py können Sie Ihre Anwendungen auf einfache Weise mithilfe einer administrativen Web-Benutzeroberfläche entwickeln und verwalten.

In diesem Handbuch wird gezeigt, wie eine web2py-Anwendung unter CentOS 7 bereitgestellt wird. Wir werden den uWSGI-Anwendungsserver verwenden, um mit der Anwendung über mehrere Arbeitsprozesse zu kommunizieren. Vor uWSGI werden wir Nginx in einer Reverse-Proxy-Konfiguration einrichten, um die tatsächlichen Client-Verbindungen zu handhaben. Dies ist eine wesentlich robustere Bereitstellungsstrategie als die alleinige Verwendung des web2py-Servers oder von uWSGI.

Voraussetzungen und Ziele

Um dieses Handbuch zu vervollständigen, sollten Sie eine neue CentOS 7-Serverinstanz mit einem Nicht-Root-Benutzer mit konfigurierten "+ sudo +" - Berechtigungen haben. Informationen zum Einrichten finden Sie in unserem initial server setup guide.

Wir werden das web2py-Framework herunterladen und es testen, um sicherzustellen, dass die Standardanwendungsumgebung ordnungsgemäß funktioniert. Anschließend werden wir den uWSGI-Anwendungscontainer herunterladen und installieren, der als Schnittstelle zwischen Anforderungen und dem web2py-Python-Code dient. Wir werden Nginx davor einrichten, damit es Client-Verbindungen und Proxy-Anfragen an uWSGI verarbeiten kann. Wir werden jede unserer Komponenten so konfigurieren, dass sie beim Booten starten, um die Notwendigkeit administrativer Eingriffe zu minimieren.

Laden Sie das web2py Framework herunter

Unser erster Schritt ist das Herunterladen des eigentlichen web2py-Frameworks. Dies wird in einem "+ git " - Repository auf GitHub gepflegt. Der beste Weg, es herunterzuladen, ist " git +".

Wir können + git + von den Standard-CentOS-Repositories herunterladen und installieren, indem wir Folgendes eingeben:

sudo yum install git

Sobald "+ git " installiert ist, können wir das Repository in das Ausgangsverzeichnis unseres Benutzers klonen. Wir können die Anwendung beliebig benennen. In unserem Beispiel verwenden wir der Einfachheit halber den Namen "+". Wir müssen das "+ - recursive " -Flag hinzufügen, da die Datenbankabstraktionsschicht als eigenes " git +" - Submodul behandelt wird:

git clone --recursive https://github.com/web2py/web2py.git ~/

Das web2py-Framework wird in ein Verzeichnis mit dem Namen "+ myapp +" in Ihrem Home-Verzeichnis heruntergeladen.

Wir können die Standardanwendung testen, indem wir in das Verzeichnis wechseln:

cd ~/

Die Verwaltungsschnittstelle muss durch SSL gesichert sein, damit wir ein einfaches selbstsigniertes Zertifikat erstellen können, um dies zu testen. Erstellen Sie den Serverschlüssel und das Zertifikat, indem Sie Folgendes eingeben:

openssl req -x509 -new -newkey rsa:4096 -days 3652 -nodes -keyout .key -out .crt

Sie müssen einige Informationen für das Zertifikat ausfüllen, das Sie generieren. Der einzige Teil, der in diesem Fall tatsächlich von Bedeutung ist, ist das Feld "+ Common Name +", das auf den Domainnamen oder die IP-Adresse Ihres Servers verweisen sollte:

. . .

Country Name (2 letter code) [AU]:US
State or Province Name (full name) [Some-State]:New York
Locality Name (eg, city) []:New York City
Organization Name (eg, company) [Internet Widgits Pty Ltd]:DigitalOcean
Organizational Unit Name (eg, section) []:
Common Name (e.g. server FQDN or YOUR name) []:
Email Address []:[email protected]

Wenn Sie fertig sind, sollten sich ein SSL-Schlüssel und ein Zertifikat in Ihrem Anwendungsverzeichnis befinden. Diese werden als "+ .key " bzw. " .crt +" bezeichnet.

Danach können wir das web2py-Webinterface starten, um es zu testen. Dazu können wir Folgendes eingeben:

python web2py.py -k .key -c .crt -i 0.0.0.0 -p 8000

Sie werden aufgefordert, ein Kennwort für die Verwaltungsschnittstelle auszuwählen.

Jetzt können Sie Ihre Anwendung in Ihrem Webbrowser aufrufen, indem Sie zu folgender Adresse navigieren:

https://:8000

Stellen Sie sicher, dass Sie in der obigen Adresse "+ https " anstelle von " http +" verwenden. Sie werden gewarnt, dass Ihr Browser das SSL-Zertifikat nicht erkennt:

image: https: //assets.digitalocean.com/articles/web2py_uwsgi_nginx_centos7/ssl_warning.png [web2py SSL warning]

Dies wird erwartet, da wir unser eigenes Zertifikat unterschrieben haben. Klicken Sie auf den Link "Erweitert" oder auf einen anderen Link, den Ihnen Ihr Browser gibt, und fahren Sie dann wie geplant mit der Website fort. Sie sehen die web2py-Oberfläche:

Bild: https://assets.digitalocean.com/articles/web2py_uwsgi_nginx_centos7/welcome_app.png [web2py welcome app]

Wenn Sie ganz rechts auf die Schaltfläche "Administrationsoberfläche" klicken, sollten Sie in der Lage sein, das Kennwort einzugeben, das Sie beim Ausführen des Servers ausgewählt haben, und zur Administrationssite zu gelangen:

image: https://assets.digitalocean.com/articles/web2py_uwsgi_nginx_centos7/admin_interface.png [Web2Py-Administrationsoberfläche]

Auf diese Weise erhalten Sie Zugriff auf den eigentlichen Code, mit dem Ihre Anwendungen ausgeführt werden, und können die Dateien über die Benutzeroberfläche selbst bearbeiten und optimieren.

Wenn Sie fertig sind, geben Sie CTRL-C in Ihr Terminalfenster ein. Wir haben unsere Anwendung getestet und gezeigt, dass auf sie im Web zugegriffen werden kann, wenn der web2py-Entwicklungsserver ausgeführt wird.

Installieren und konfigurieren Sie uWSGI

Nachdem die web2py-Anwendung nun betriebsbereit ist, können wir uWSGI konfigurieren. uWSGI ist ein Anwendungsserver, der über eine Standardschnittstelle namens WSGI mit Anwendungen kommunizieren kann. Weitere Informationen hierzu finden Sie unter https://www.digitalocean.com/community/tutorials/how-to-set-up-uwsgi-and-nginx-to-serve-python-apps-on-ubuntu-14-04 # Definitionen und Konzepte [dieser Abschnitt] unseres Handbuchs zum Einrichten von uWSGI und Nginx unter Ubuntu 14.04.

UWSGI installieren

Im Gegensatz zu der oben verlinkten Anleitung installieren wir in diesem Lernprogramm uWSGI global. Bevor wir uWSGI installieren können, müssen wir + pip +, den Python-Paketmanager und die Python-Entwicklungsdateien installieren, auf die sich uWSGI stützt. Wir werden auch einen Compiler brauchen, um die eigentliche Binärdatei zu erstellen. Um "+ pip +" zu erhalten, müssen wir das EPEL-Repository verwenden, das zusätzliche Pakete enthält.

Wir können das EPEL-Repository aktivieren, indem wir Folgendes eingeben:

sudo yum install epel-release

Anschließend können wir die benötigten Pakete durch Eingabe installieren

sudo yum install python-devel python-pip gcc

Jetzt können wir uWSGI global mit + pip + installieren, indem wir Folgendes eingeben:

sudo pip install uwsgi

Der uWSGI-Anwendungscontainerserver ist über die WSGI-Schnittstellenspezifikation mit Python-Anwendungen verbunden. Das web2py-Framework enthält eine Datei, die diese Schnittstelle im Verzeichnis + handlers + bereitstellt. Um die Datei zu verwenden, müssen wir sie aus dem Verzeichnis in das Hauptprojektverzeichnis verschieben:

mv ~//handlers/wsgihandler.py ~/

Mit dem WSGI-Handler im Hauptprojektverzeichnis können wir überprüfen, ob uWSGI die Anwendung bedienen kann, indem wir Folgendes eingeben:

uwsgi --http :8000 --chdir ~/ -w wsgihandler:application

Dadurch sollte die Anwendung auf Port 8000 erneut gestartet werden. Dieses Mal wird das SSL-Zertifikat und der SSL-Schlüssel nicht über HTTP, sondern über HTTPS bereitgestellt. Sie können dies in Ihrem Browser erneut mit dem Protokoll "+ http +" testen. Sie können die Administrationsoberfläche nicht testen, da dies von web2py deaktiviert wird, wenn keine Verschlüsselung verfügbar ist.

Wenn Sie fertig sind, geben Sie STRG-C in Ihr Terminalfenster ein, um den Server zu stoppen.

Erstellen einer uWSGI-Konfigurationsdatei

Nachdem wir wissen, dass uWSGI die Anwendung bedienen kann, können wir eine uWSGI-Konfigurationsdatei mit den Informationen unserer Anwendung erstellen.

Erstellen Sie ein Verzeichnis unter "+ / etc / uwsgi / sites +", um unsere Konfigurationen zu speichern, und verschieben Sie es in dieses Verzeichnis:

sudo mkdir -p /etc/uwsgi/sites
cd /etc/uwsgi/sites

Wir werden unsere Konfigurationsdatei "+ myapp.ini +" aufrufen:

sudo nano .ini

In der Konfigurationsdatei müssen wir mit einem "+ [uwsgi] +" - Header beginnen, unter dem alle unsere Konfigurationsanweisungen abgelegt werden. Nach dem Header geben wir den Verzeichnispfad unserer Anwendung an und teilen ihm das auszuführende Modul mit. Dies sind die gleichen Informationen, die wir zuvor in der Befehlszeile verwendet haben. Sie müssen die Modulzeile nicht ändern:

[uwsgi]
chdir = /home//
module = wsgihandler:application

Als nächstes müssen wir festlegen, dass uWSGI im Master-Modus betrieben werden soll. Wir wollen fünf Worker-Prozesse erzeugen:

[uwsgi]
chdir = /home//
module = wsgihandler:application

master = true
processes = 5

Als nächstes müssen wir festlegen, wie uWSGI Verbindungen erhalten soll. In unserem Test des uWSGI-Servers haben wir normale HTTP-Verbindungen akzeptiert. Da wir Nginx jedoch als Reverse-Proxy vor uWSGI konfigurieren, haben wir andere Optionen.

Anstatt einen Netzwerkport zu verwenden, können wir einen Unix-Socket verwenden, da alle Komponenten auf einem einzelnen Server ausgeführt werden. Dies ist sicherer und bietet eine bessere Leistung. Dieser Socket verwendet kein HTTP, sondern implementiert stattdessen das uWSGI-Protokoll "+ uwsgi ", ein schnelles Binärprotokoll für die Kommunikation mit anderen Servern. Nginx kann nativ Proxys mit dem " uwsgi +" - Protokoll erstellen, daher ist dies unsere beste Wahl.

Wir müssen den Benutzer, der die Prozesse ausführt, auf unseren eigenen Benutzer festlegen, da uns die Dateien gehören. Wir werden auch die Berechtigungen und den Besitz des Sockets ändern, da wir dem Webserver Schreibzugriff gewähren. Der Socket selbst wird im Verzeichnis "+ / run / uwsgi +" abgelegt (wir erstellen dieses Verzeichnis in Kürze), in dem sowohl uWSGI als auch Nginx darauf zugreifen können. Wir stellen die Vakuum-Option so ein, dass die Socket-Datei automatisch bereinigt wird, wenn der Dienst beendet wird:

[uwsgi]
chdir = /home//
module = wsgihandler:application

master = true
processes = 5

uid =
socket = /run/uwsgi/.sock
chown-socket = :nginx
chmod-socket = 660
vacuum = true

Unsere uWSGI-Konfigurationsdatei ist jetzt vollständig. Speichern und schließen Sie die Datei.

Erstellen Sie eine Systemd Unit-Datei für uWSGI

Wir haben eine Konfigurationsdatei für uWSGI erstellt, aber unseren Anwendungsserver noch nicht so eingerichtet, dass er beim Booten automatisch startet. Um diese Funktionalität zu implementieren, können wir eine Systemd-Unit-Datei erstellen.

Wir erstellen die Unit-Datei im Verzeichnis "+ / etc / systemd / system ", in dem vom Benutzer erstellte Unit-Dateien gespeichert werden. Wir rufen Ihre Datei " uwsgi.service" auf:

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

Beginnen Sie mit dem Abschnitt "+ [Unit] +", in dem Metadaten angegeben werden. Hier geben wir einfach eine Beschreibung unseres Service:

[Unit]
Description=uWSGI Emperor service

Als Nächstes öffnen wir den Abschnitt [Service]. Wir werden die ExecStartPre-Direktive verwenden, um die Teile einzurichten, die wir zum Ausführen unseres Servers benötigen. Dadurch wird sichergestellt, dass das Verzeichnis / run / uwsgi erstellt wird und dass es unserem normalen Benutzer mit der Nginx-Gruppe als Gruppeneigentümer gehört. Sowohl mkdir mit dem Flag -p als auch der Befehl chown geben erfolgreich zurück, auch wenn sie bereits vorhanden sind. Das wollen wir.

Für den eigentlichen Startbefehl, der von der ExecStart-Direktive angegeben wird, verweisen wir auf die ausführbare Datei uwsgi. Wir werden es anweisen, im "Emperor-Modus" zu laufen, damit es mehrere Anwendungen mit den Dateien verwalten kann, die es in / etc / uwsgi / sites findet. Wir werden auch die Teile hinzufügen, die Systemd benötigt, um den Prozess korrekt zu verwalten. Diese stammen aus der uWSGI-Dokumentation here:

[Unit]
Description=uWSGI Emperor service

[Service]
ExecStartPre=/usr/bin/bash -c 'mkdir -p /run/uwsgi; chown :nginx /run/uwsgi'
ExecStart=/usr/bin/uwsgi --emperor /etc/uwsgi/sites
Restart=always
KillSignal=SIGQUIT
Type=notify
NotifyAccess=all

Jetzt müssen wir nur noch den Abschnitt [Install] hinzufügen. Auf diese Weise können wir festlegen, wann der Dienst automatisch gestartet werden soll. Wir werden unseren Service an den Multi-User-Systemstatus binden. Immer wenn das System für mehrere Benutzer eingerichtet ist (normaler Betriebszustand), wird unser Service aktiviert:

[Unit]
Description=uWSGI Emperor service

[Service]
ExecStartPre=/usr/bin/bash -c 'mkdir -p /run/uwsgi; chown :nginx /run/uwsgi'
ExecStart=/usr/bin/uwsgi --emperor /etc/uwsgi/sites
Restart=always
KillSignal=SIGQUIT
Type=notify
NotifyAccess=all

[Install]
WantedBy=multi-user.target

Wenn Sie damit fertig sind, speichern und schließen Sie die Datei.

Der Dienst kann zu diesem Zeitpunkt nicht erfolgreich gestartet werden, da der Nginx-Benutzer verfügbar ist. Wir müssen warten, bis der uWSGI-Dienst nach der Installation von Nginx gestartet wird.

Installieren und konfigurieren Sie Nginx als Reverse Proxy

Nachdem uWSGI konfiguriert und einsatzbereit ist, können wir jetzt Nginx als unseren Reverse-Proxy installieren und konfigurieren. Dies kann mit + yum + heruntergeladen werden, indem Folgendes eingegeben wird:

sudo yum install nginx

Sobald Nginx installiert ist, können wir die Serverblockkonfiguration ändern. Wir werden die Hauptkonfigurationsdatei von Nginx bearbeiten:

sudo nano /etc/nginx/nginx.conf

Die web2py-Anwendung erkennt, ob Sie eine Verbindung mit normalem HTTP oder mit SSL-Verschlüsselung herstellen. Aus diesem Grund enthält unsere Datei tatsächlich jeweils einen Serverblock. Wir beginnen mit dem Serverblock, der für den Betrieb an Port 80 konfiguriert ist.

Ändern Sie "+ Servername ", um auf den Domainnamen oder die IP-Adresse zu verweisen, auf die Ihre Site zugreifen soll. Danach erstellen wir einen ` location {} ` Block, der Anfragen nach statischem Inhalt entspricht. Grundsätzlich möchten wir reguläre Ausdrücke verwenden, um Anforderungen, die mit " / static / " enden, mit einer vorhergehenden Pfadkomponente abzugleichen. Wir möchten diese Anforderungen dem Verzeichnis " applications +" in unserem web2py-Projekt zuordnen. Stellen Sie sicher, dass Sie auf das Basisverzeichnis und den App-Namen Ihres Benutzers verweisen:

server {
   listen                  80 default_server;
   server_name             ;
   root                    /usr/share/nginx/html;

   include /etc/nginx/default.d/*.conf;





   . . .

Danach müssen wir den + location / {} + Block anpassen, um Anfragen an unseren uWSGI-Socket weiterzuleiten. Wir müssen nur die mit Nginx gepackte uWSGI-Parameterdatei einfügen und die Anforderungen an den von uns konfigurierten Socket übergeben (in unserer uWSGI-Datei + .ini +):

server {
   listen                  80 default_server;
   server_name             ;
   root                    /usr/share/nginx/html;

   include /etc/nginx/default.d/*.conf;

   location ~* /(\w+)/static/ {
       root /home/user/myapp/applications/;
   }

   location / {


   }
}

   . . .

Dies ist alles, was wir für unseren ersten Serverblock benötigen.

Erstellen Sie am Ende der Datei, aber in der schließenden Klammer "+ http {} " einen weiteren " server {} +" -Block. Wir werden dies verwenden, um SSL-Verbindungen zu konfigurieren.

Beginnen Sie mit den Grundlagen. Dieser Serverblock wartet auf Verbindungen an Port 443, dem Standard-SSL-Port. Wir werden den Domainnamen oder die IP-Adresse des Servers genau wie für den Port 80-Serverblock festlegen. Um die eigentliche SSL-Konfiguration zu starten, geben wir an, dass SSL für diesen Block aktiviert sein soll, und geben den Pfad zum SSL-Zertifikat und den Schlüssel an, die zum Verschlüsseln der Verbindung verwendet werden sollen. Wir werden die Dateien vorübergehend dorthin verschieben:

http {
   . . .
   server {
       listen 80;
       . . .
   }








}

Wir werden mit etwas SSL-Boilerplate fortfahren, um die akzeptierten Protokolle und Chiffren festzulegen. Danach können wir den gleichen + location / {} + Block einrichten, den wir im Port 80 Server Block konfiguriert haben:

http {
   . . .
   server {
       listen 80;
       . . .
   }
   server {
       listen 443;
       server_name ;

       ssl on;
       ssl_certificate /etc/nginx/ssl/myapp.crt;
       ssl_certificate_key /etc/nginx/ssl/myapp.key;









   }
}

In dieser Datei sollten nun zwei Serverblöcke konfiguriert sein. Speichern und schließen Sie es, wenn Sie fertig sind.

Letzte Schritte

Als nächstes müssen wir die SSL-Zertifikate in das von uns angegebene Verzeichnis verschieben. Erstellen Sie zuerst das Verzeichnis:

sudo mkdir -p /etc/nginx/ssl

Verschieben Sie nun das Zertifikat und den Schlüssel, die Sie erstellt haben, in dieses Verzeichnis. Wenn Sie ein von einer kommerziellen Zertifizierungsstelle signiertes SSL-Zertifikat haben, können Sie das Zertifikat und den entsprechenden Schlüssel hier ersetzen, um nicht vertrauenswürdige SSL-Zertifikatswarnungen für Ihre Besucher zu vermeiden:

sudo mv ~//.crt /etc/nginx/ssl
sudo mv ~//.key /etc/nginx/ssl

Ändern Sie die Berechtigungen, damit Benutzer ohne Rootberechtigung nicht auf dieses Verzeichnis zugreifen können:

sudo chmod 700 /etc/nginx/ssl

Der Benutzer "+ nginx " muss Zugriff auf unser Anwendungsverzeichnis haben, damit er bei Bedarf statische Dateien direkt bereitstellen kann. CentOS sperrt das Home-Verzeichnis jedes Benutzers sehr restriktiv, sodass wir den Benutzer " nginx +" zur Gruppe unserer Benutzer hinzufügen, damit wir dann die Mindestberechtigungen öffnen können, die erforderlich sind, damit dies funktioniert.

Fügen Sie den Benutzer "+ nginx " zu Ihrer Gruppe hinzu, indem Sie dies eingeben. Ersetzen Sie Ihren Benutzernamen durch das " user +" im folgenden Befehl:

sudo usermod -a -G  nginx

Jetzt erteilen wir unserer Benutzergruppe Ausführungsberechtigungen für unser Verzeichnis, mit denen der Nginx-Prozess Inhalte eingeben und darauf zugreifen kann, die in folgenden Bereichen ausgeführt werden:

chmod 710 /home/

Überprüfen Sie nun Ihre Nginx-Konfigurationsdatei auf Syntaxfehler:

sudo nginx -t

Wenn keine Syntaxfehler gemeldet werden, können wir Nginx starten:

sudo service nginx start

Wir können auch unseren uWSGI-Dienst starten:

sudo service uwsgi start

Als letztes müssen wir die Parameterdatei unserer Anwendung kopieren, damit sie beim Bereitstellen von Verbindungen auf Port 443 korrekt gelesen wird. Dieses enthält das Kennwort, das wir für die Verwaltungsschnittstelle konfiguriert haben. Wir müssen es nur in einen neuen Namen kopieren, der Port 443 anstelle von Port 8000 angibt:

cp ~//parameters_8000.py ~//parameters_443.py

Damit sollten Sie in der Lage sein, über den Domainnamen oder die IP-Adresse Ihres Servers auf Ihren Server zuzugreifen. Verwenden Sie "+ https +", wenn Sie sich bei der Verwaltungsoberfläche anmelden möchten.

Wenn alles gut geht, können Sie Nginx und uWSGI aktivieren, indem Sie Folgendes eingeben:

sudo systemctl enable nginx
sudo systemctl enable uwsgi

Fazit

In diesem Handbuch haben wir ein Beispielprojekt für web2py eingerichtet, um die Bereitstellung zu üben. Wir haben uWSGI so konfiguriert, dass es als Schnittstelle zwischen unserer Anwendung und Kundenanforderungen fungiert. Anschließend haben wir Nginx vor uWSGI eingerichtet, um SSL-Verbindungen zu ermöglichen und Client-Anforderungen effizient zu verarbeiten.

Das web2py-Projekt vereinfacht die Entwicklung von Websites und Webanwendungen, indem von Anfang an ein funktionsfähiges Webinterface bereitgestellt wird. Indem Sie die in diesem Artikel beschriebene allgemeine Toolkette nutzen, können Sie die von Ihnen erstellten Anwendungen problemlos von einem einzelnen Server aus bereitstellen.

Related