Flup installieren: Unterschied zwischen den Versionen

Aus Hostsharing Wiki
Zur Navigation springen Zur Suche springen
KKeine Bearbeitungszusammenfassung
 
Zeile 22: Zeile 22:
Man kann diverse Varianten der WSGIServer-Implementation importieren:
Man kann diverse Varianten der WSGIServer-Implementation importieren:


user@hNN:~$ python
<syntaxhighlight lang=shell>
Python 2.5.2 (r252:60911, Jan  4 2009, 17:40:26)
user@hNN:~$ python
[GCC 4.3.2] on linux2
Python 2.5.2 (r252:60911, Jan  4 2009, 17:40:26)
Type "help", "copyright", "credits" or "license" for more information.
[GCC 4.3.2] on linux2
>>> from flup.server.fcgi import WSGIServer
Type "help", "copyright", "credits" or "license" for more information.
>>> from flup.server.cgi import WSGIServer
>>> from flup.server.fcgi import WSGIServer
>>> from flup.server.scgi import WSGIServer
>>> from flup.server.cgi import WSGIServer
>>> from flup.server.ajp import WSGIServer
>>> from flup.server.scgi import WSGIServer
>>> from flup.server.ajp import WSGIServer
</syntaxhighlight>


=== Wrapper erstellen ===
=== Wrapper erstellen ===
Zeile 40: Zeile 42:
The WSGI handler is quite simple. The following sample code shows how to use it:
The WSGI handler is quite simple. The following sample code shows how to use it:


<nowiki>from wsgiref.simple_server import make_server
<syntaxhighlight lang=php line>
from wsgiref.simple_server import make_server
# obtain the WSGI request dispatcher
# obtain the WSGI request dispatcher
from roundup.cgi.wsgi_handler import RequestDispatcher
from roundup.cgi.wsgi_handler import RequestDispatcher
Zeile 46: Zeile 49:
app = RequestDispatcher(tracker_home)
app = RequestDispatcher(tracker_home)
httpd = make_server('', 8917, app)
httpd = make_server('', 8917, app)
httpd.serve_forever()</nowiki>
httpd.serve_forever()
 
</syntaxhighlight>
To test the above you should create a demo tracker with python demo.py.
To test the above you should create a demo tracker with python demo.py.
Edit the config.ini to change the web URL to <code>http://localhost:8917/</code>.
Edit the config.ini to change the web URL to <code>http://localhost:8917/</code>.
Zeile 79: Zeile 82:
'''Wrapper für CGI:'''
'''Wrapper für CGI:'''


  #!/usr/bin/env python
<syntaxhighlight lang=python line>
  import sys
#!/usr/bin/env python
  sys.path.append("/home/pacs/xyz00/users/USERNAME/roundup/install/lib/python2.5/site-packages")
import sys
  from flup.server.cgi import WSGIServer
sys.path.append("/home/pacs/xyz00/users/USERNAME/roundup/install/lib/python2.5/site-packages")
  # obtain the WSGI request dispatcher
from flup.server.cgi import WSGIServer
  from roundup.cgi.wsgi_handler import RequestDispatcher
# obtain the WSGI request dispatcher
  tracker_home = '/pfad/zum/tracker/home/verzeichnis'
from roundup.cgi.wsgi_handler import RequestDispatcher
  app = RequestDispatcher(tracker_home)
tracker_home = '/pfad/zum/tracker/home/verzeichnis'
  WSGIServer(app).run()
app = RequestDispatcher(tracker_home)
WSGIServer(app).run()
</syntaxhighlight>


'''Skizze für FastCGI:'''
'''Skizze für FastCGI:'''


#!/usr/bin/env python
<syntaxhighlight lang=python line>
from '''fcgi''' import WSGIServer
#!/usr/bin/env python
'''# hier: fastcgi'''
from '''fcgi''' import WSGIServer
from myapplication import app
'''# hier: fastcgi'''
# Hier muss ich schauen,
from myapplication import app
# dass ich das app-Objekt meiner Applikation importiert bekomme.
# Hier muss ich schauen,
# im obigen Fall also app = RequestDispatcher(tracker_home)
# dass ich das app-Objekt meiner Applikation importiert bekomme.
WSGIServer(app).run()
# im obigen Fall also app = RequestDispatcher(tracker_home)
WSGIServer(app).run()
</syntaxhighlight>


Für [[Django]] läuft die Erstellung eines Wrappers analog.
Für [[Django]] läuft die Erstellung eines Wrappers analog.
Zeile 114: Zeile 121:
Zunächst legt man das FastCGI-Skript (python.fcgi) an und legt es im fastcgi-ssl Verzeichnis ab und macht es ausführbar:
Zunächst legt man das FastCGI-Skript (python.fcgi) an und legt es im fastcgi-ssl Verzeichnis ab und macht es ausführbar:


<pre>
<syntaxhighlight lang=shell>
xyz-doms:~$ cd doms/example.com
xyz-doms:~$ cd doms/example.com
xyz-doms:~$ export path_to_domain=`pwd`
xyz-doms:~$ export path_to_domain=`pwd`
Zeile 132: Zeile 139:


xyz-doms:~$ chmod a+x fastcgi-ssl/python.fcgi
xyz-doms:~$ chmod a+x fastcgi-ssl/python.fcgi
</pre>
</syntaxhighlight>


Nun muss noch die eigentliche App angelegt werden:
Nun muss noch die eigentliche App angelegt werden:


<pre>
<syntaxhighlight lang=shell>
xyz-doms:~$ cd doms/example.com
xyz-doms:~$ cd doms/example.com
xyz-doms:~$ mkdir myproject
xyz-doms:~$ mkdir myproject
Zeile 148: Zeile 155:
     return iter([data])
     return iter([data])
FINISH
FINISH
</pre>
</syntaxhighlight>


Nun ist die Seite unter www.example.com/fastcgi-bin/python.fcgi erreichbar.
Nun ist die Seite unter www.example.com/fastcgi-bin/python.fcgi erreichbar.
Zeile 157: Zeile 164:


Zun&auml;chst wird die Virtualenvumgebung erstellt:
Zun&auml;chst wird die Virtualenvumgebung erstellt:
<pre>
<syntaxhighlight lang=shell>
xyz00-doms:~$ virtualenv -p /usr/bin/python3 pyenv
xyz00-doms:~$ virtualenv -p /usr/bin/python3 pyenv
Already using interpreter /usr/bin/python3
Already using interpreter /usr/bin/python3
Zeile 164: Zeile 171:
Also creating executable in pyenv/bin/python
Also creating executable in pyenv/bin/python
Installing setuptools, pkg_resources, pip, wheel...done.
Installing setuptools, pkg_resources, pip, wheel...done.
</pre>
</syntaxhighlight>
Dann werden die benötigten Bibliotheken in die eben erstellte Virtualenvumgebung installiert.
Dann werden die benötigten Bibliotheken in die eben erstellte Virtualenvumgebung installiert.
<pre>
<syntaxhighlight lang=shell>
xyz-doms:~$ source pyenv/bin/activate
xyz-doms:~$ source pyenv/bin/activate
(pyenv) xyz-doms:~$ pip3 install flask flup
(pyenv) xyz-doms:~$ pip3 install flask flup
  ...
  ...
  Successfully installed Jinja2-2.11.2 MarkupSafe-1.1.1 Werkzeug-1.0.1 click-7.1.2 flask-1.1.2 flup-1.0.3 itsdangerous-1.1.0
  Successfully installed Jinja2-2.11.2 MarkupSafe-1.1.1 Werkzeug-1.0.1 click-7.1.2 flask-1.1.2 flup-1.0.3 itsdangerous-1.1.0
</pre>
</syntaxhighlight>


Nun legt man das FastCGI-Skript (python.fcgi) an und legt es im fastcgi-ssl Verzeichnis ab und macht es ausführbar:
Nun legt man das FastCGI-Skript (python.fcgi) an und legt es im fastcgi-ssl Verzeichnis ab und macht es ausführbar:


<pre>
<syntaxhighlight lang=shell>
xyz-doms:~$ export pyenv=$HOME/pyenv
xyz-doms:~$ export pyenv=$HOME/pyenv
xyz-doms:~$ cd doms/example.com
xyz-doms:~$ cd doms/example.com
Zeile 194: Zeile 201:


xyz-doms:~$ chmod a+x fastcgi-ssl/python.fcgi
xyz-doms:~$ chmod a+x fastcgi-ssl/python.fcgi
</pre>
</syntaxhighlight>


Nun muss noch die eigentliche App angelegt werden:
Nun muss noch die eigentliche App angelegt werden:


<pre>
<syntaxhighlight lang=shell>
xyz-doms:~$ cd doms/example.com
xyz-doms:~$ cd doms/example.com
xyz-doms:~$ mkdir myproject
xyz-doms:~$ mkdir myproject
Zeile 212: Zeile 219:
     app.run(host='0.0.0.0')
     app.run(host='0.0.0.0')
FINISH
FINISH
</pre>
</syntaxhighlight>


Nun ist die Seite unter www.example.com/fastcgi-bin/python.fcgi erreichbar.
Nun ist die Seite unter www.example.com/fastcgi-bin/python.fcgi erreichbar.
Zeile 224: Zeile 231:
Hierf&uuml;r wird eine .htaccess im entsprechenden Domainverzeichnis angelegt:
Hierf&uuml;r wird eine .htaccess im entsprechenden Domainverzeichnis angelegt:


<pre>
<syntaxhighlight lang=shell>
xyz-doms:~$ cd doms/example.com
xyz-doms:~$ cd doms/example.com
xyz-doms:~$ cat > .htaccess <<FINISH
xyz-doms:~$ cat > .htaccess <<FINISH
Zeile 231: Zeile 238:
RewriteRule ^(.*)$ /fastcgi-bin/python.fcgi/$1 [QSA,L]
RewriteRule ^(.*)$ /fastcgi-bin/python.fcgi/$1 [QSA,L]
FINISH
FINISH
</pre>
</syntaxhighlight>


Nun sollte die Seite unter (www.)example.com erreichbar sein.
Nun sollte die Seite unter (www.)example.com erreichbar sein.
Zeile 237: Zeile 244:
==== Server soll Änderungen in der App übernehmen ====
==== Server soll Änderungen in der App übernehmen ====
Manchmal werden Änderungen in den Quellen nicht übernommen. Dann hilft es den Zeitstempel der Datei python.fcgi mit touch zu aktualisieren:
Manchmal werden Änderungen in den Quellen nicht übernommen. Dann hilft es den Zeitstempel der Datei python.fcgi mit touch zu aktualisieren:
<pre>
<syntaxhighlight lang=shell>
xyz-doms:~$ touch doms/example.com/fastcgi-ssl/python.fcgi
xyz-doms:~$ touch doms/example.com/fastcgi-ssl/python.fcgi
</pre>
</syntaxhighlight>


Alternativ kann der Prozess gestoppt werden:
Alternativ kann der Prozess gestoppt werden:
<pre>
<syntaxhighlight lang=shell>
xyz-doms:~$ ps xaf | grep pyenv | grep -v grep
xyz-doms:~$ ps xaf | grep pyenv | grep -v grep
  7195 ?        Sl    0:01  |  \_ /.../pyenv/bin/python python.fcgi
  7195 ?        Sl    0:01  |  \_ /.../pyenv/bin/python python.fcgi
xyz-doms:~$ kill 7195
xyz-doms:~$ kill 7195
</pre>
</syntaxhighlight>


oder in einer Zeile:
oder in einer Zeile:
<pre>
<syntaxhighlight lang=shell>
xyz-doms:~$ kill `ps xaf | grep pyenv | grep -v grep | awk '{print $1}'`
xyz-doms:~$ kill `ps xaf | grep pyenv | grep -v grep | awk '{print $1}'`
</pre>
</syntaxhighlight>


==== Debuggen einer Anwendung ====
==== Debuggen einer Anwendung ====
Wenn es einen Fehler in der Anwendung gibt, oder auch nur schon Syntaxfehler, kann es hilfreich sein, die Anwendung lokal zu starten:
Wenn es einen Fehler in der Anwendung gibt, oder auch nur schon Syntaxfehler, kann es hilfreich sein, die Anwendung lokal zu starten:


<pre>
<syntaxhighlight lang=shell>
xyz-doms:~$ source pyenv/bin/activate
xyz-doms:~$ source pyenv/bin/activate
(pyenv) xyz-doms:~$ python3 doms/example.com/myproject/myproject.py
(pyenv) xyz-doms:~$ python3 doms/example.com/myproject/myproject.py
Zeile 265: Zeile 272:
  * Debug mode: off
  * Debug mode: off
  * Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)
  * Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)
</pre>
</syntaxhighlight>


Dann wird auf einer anderen Konsole die Abfrage an den Server geschickt:
Dann wird auf einer anderen Konsole die Abfrage an den Server geschickt:


<pre>
<syntaxhighlight lang=shell>
xyz-doms:~$ curl http://localhost:5000
xyz-doms:~$ curl http://localhost:5000
</pre>
</syntaxhighlight>


Nun sieht man auf der ersten Konsole die Ausgabe.
Nun sieht man auf der ersten Konsole die Ausgabe.

Aktuelle Version vom 1. Juli 2024, 11:32 Uhr

Motivation

Im Python-Bereich existieren viele Anwendungen, die die CGI-Schnittstelle unterstützen. FastCGI auf direktem Wege ist eher ungebräuchlich.

Seit einigen Jahren etabliert sich für Python-Anwendungen und -Frameworks der Python Standard WSGI [1], eine Schnittstelle zur Kommunikation zwischen einem Webserver und einer Python-Webanwendung.

Beispielsweise roundup, Django, Trac und die kommende Mailman-Generation WSGI-fähig. Sogar für Zope gibt es mit Repoze eine WSGI-Implementierung.

Direkte Unterstützung für WSGI bieten wir über mod_wsgi, welches leider, wie auch mod_jk Benutzer der Option "eigene httpd.conf" vorbehalten ist, da hierfür der VirtualHost speziell konfiguriert werden muss.

Im Regelfall möchte man vermutlich jedoch nicht unbedingt die Option "eigene httpd.conf" bestellen. Einen Lösungsansatz bietet flup [2], welcher u.a. auch von Trac genutzt wird, um OOTB eine CGI- und FastCGI-Schnittstelle anzubieten. Flup kann also als Adapter zwischen der CGI- oder FastCGI-Schnittstelle des Webservers und der WSGI-Schnittstelle einer Webanwendung fungieren. Aus Performancegründen empfiehlt sich regelmäßig FastCGI. Daneben bietet flup diverse weitere Schnittstellen [3].

Auch der Einsatz von CGI, FastCGI, WSGI*, SCGI* oder AJP* erfordern keinen Root-Server, sondern ist mit Hostsharing-Bordmitteln möglich.

Anmerkung

* Ohne Adapter (etwa FastCGI <-> WSGI) erfordern diese Schnittstellen die Option "eigene httpd.conf". Mit gebuchter Option "eigene httpd.conf" können diese Schnittstellen auf direktem Wege (wie auf einem Root-Server) konfiguriert werden.


Anmerkung

Wo immer WSGI eingesetzt werden kann, sollte Passenger verwendet werden. Das ist viel einfacher zu konfigurieren. Siehe z.B. Django installieren bzw. Flask installieren


Nutzung von flup

flup ist bei HS zentral installiert. Man kann diverse Varianten der WSGIServer-Implementation importieren:

user@hNN:~$ python
Python 2.5.2 (r252:60911, Jan  4 2009, 17:40:26)
[GCC 4.3.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from flup.server.fcgi import WSGIServer
>>> from flup.server.cgi import WSGIServer
>>> from flup.server.scgi import WSGIServer
>>> from flup.server.ajp import WSGIServer

Wrapper erstellen

Beispiel für roundup

zusammen mit

WSGI Handler

The WSGI handler is quite simple. The following sample code shows how to use it:

from wsgiref.simple_server import make_server
# obtain the WSGI request dispatcher
from roundup.cgi.wsgi_handler import RequestDispatcher
tracker_home = 'demo'
app = RequestDispatcher(tracker_home)
httpd = make_server('', 8917, app)
httpd.serve_forever()

To test the above you should create a demo tracker with python demo.py. Edit the config.ini to change the web URL to http://localhost:8917/.


und

aus der flup-Doku

28 	fcgi - a FastCGI/WSGI gateway.
29 	
30 	For more information about FastCGI, see <http://www.fastcgi.com/>.
31 	
32 	For more information about the Web Server Gateway Interface, see
33 	<http://www.python.org/peps/pep-0333.html>.
34 	
35 	Example usage:
36 	
37 	  #!/usr/bin/env python
38 	  from myapplication import app # Assume app is your WSGI application object
39 	  from fcgi import WSGIServer
40 	  WSGIServer(app).run()


kann man einen Wrapper basteln, der

  • ein gültiges CGI- oder FastCGI-Skript darstellt
  • und einen WSGI-Server für die Applikation implementiert

Wrapper für CGI:

#!/usr/bin/env python
import sys
sys.path.append("/home/pacs/xyz00/users/USERNAME/roundup/install/lib/python2.5/site-packages")
from flup.server.cgi import WSGIServer
# obtain the WSGI request dispatcher
from roundup.cgi.wsgi_handler import RequestDispatcher
tracker_home = '/pfad/zum/tracker/home/verzeichnis'
app = RequestDispatcher(tracker_home)
WSGIServer(app).run()

Skizze für FastCGI:

#!/usr/bin/env python
from '''fcgi''' import WSGIServer
'''# hier: fastcgi'''
from myapplication import app
# Hier muss ich schauen,
# dass ich das app-Objekt meiner Applikation importiert bekomme.
# im obigen Fall also app = RequestDispatcher(tracker_home)
WSGIServer(app).run()

Für Django läuft die Erstellung eines Wrappers analog. Wichtig ist in jedem Fall ein App-Objekt für die Zielsoftware. Trac bringt freundlicherweise einen fertigen "Stub" mit.

[1] http://www.python.org/dev/peps/pep-0333/
[2] http://trac.saddi.com/flup
[3] http://trac.saddi.com/flup/browser/flup/server

Ganz einfaches Hello World Beispiel

Flup ist auf dem Hostsharing Server bereits für Python2 installiert.

Zunächst legt man das FastCGI-Skript (python.fcgi) an und legt es im fastcgi-ssl Verzeichnis ab und macht es ausführbar:

xyz-doms:~$ cd doms/example.com
xyz-doms:~$ export path_to_domain=`pwd`
xyz-doms:~$ cat > fastcgi-ssl/python.fcgi <<FINISH
#!/usr/bin/env python

import os, sys
from flup.server.fcgi import WSGIServer

os.chdir("$path_to_domain/myproject")
sys.path.insert(0, "$path_to_domain/myproject")

from myproject import app

WSGIServer(app).run()
FINISH

xyz-doms:~$ chmod a+x fastcgi-ssl/python.fcgi

Nun muss noch die eigentliche App angelegt werden:

xyz-doms:~$ cd doms/example.com
xyz-doms:~$ mkdir myproject
xyz-doms:~$ cat > myproject/myproject.py <<FINISH
def app(environ, start_response):
    data = b"Hello, World!\n"
    start_response("200 OK", [
        ("Content-Type", "text/plain"),
        ("Content-Length", str(len(data)))
    ])
    return iter([data])
FINISH

Nun ist die Seite unter www.example.com/fastcgi-bin/python.fcgi erreichbar.

Erweitertes Hello World Beispiel mit Python3 und Flask

Falls man auf ein eigenes Python Virtualenv setzen möchte, weil man z.B. Python3 mit weiteren Paketen nutzen möchte, kann man folgendermaßen vorgehen:

Zunächst wird die Virtualenvumgebung erstellt:

xyz00-doms:~$ virtualenv -p /usr/bin/python3 pyenv
Already using interpreter /usr/bin/python3
Using base prefix '/usr'
New python executable in pyenv/bin/python3
Also creating executable in pyenv/bin/python
Installing setuptools, pkg_resources, pip, wheel...done.

Dann werden die benötigten Bibliotheken in die eben erstellte Virtualenvumgebung installiert.

xyz-doms:~$ source pyenv/bin/activate
(pyenv) xyz-doms:~$ pip3 install flask flup
 ...
 Successfully installed Jinja2-2.11.2 MarkupSafe-1.1.1 Werkzeug-1.0.1 click-7.1.2 flask-1.1.2 flup-1.0.3 itsdangerous-1.1.0

Nun legt man das FastCGI-Skript (python.fcgi) an und legt es im fastcgi-ssl Verzeichnis ab und macht es ausführbar:

xyz-doms:~$ export pyenv=$HOME/pyenv
xyz-doms:~$ cd doms/example.com
xyz-doms:~$ export path_to_domain=`pwd`
xyz-doms:~$ cat > fastcgi-ssl/python.fcgi <<FINISH
#!$pyenv/bin/python

import os, sys
from flup.server.fcgi import WSGIServer

os.chdir("$path_to_domain/myproject")
sys.path.insert(0, "$path_to_domain/myproject")

from myproject import app

WSGIServer(app).run()
FINISH

xyz-doms:~$ chmod a+x fastcgi-ssl/python.fcgi

Nun muss noch die eigentliche App angelegt werden:

xyz-doms:~$ cd doms/example.com
xyz-doms:~$ mkdir myproject
xyz-doms:~$ cat > myproject/myproject.py <<FINISH
from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "<h1 style='color:blue'>Hello There!</h1>"

if __name__ == "__main__":
    app.run(host='0.0.0.0')
FINISH

Nun ist die Seite unter www.example.com/fastcgi-bin/python.fcgi erreichbar.

Hilfreiche Tipps

Seite direkt auf www.example.com verfügbar machen

Erstmal ist die Seite nur unter www.example.com/fastcgi-bin/python.fcgi erreichbar.

So wird das Projekt unter www.example.com verfügbar gemacht:

Hierfür wird eine .htaccess im entsprechenden Domainverzeichnis angelegt:

xyz-doms:~$ cd doms/example.com
xyz-doms:~$ cat > .htaccess <<FINISH
RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-f
RewriteRule ^(.*)$ /fastcgi-bin/python.fcgi/$1 [QSA,L]
FINISH

Nun sollte die Seite unter (www.)example.com erreichbar sein.

Server soll Änderungen in der App übernehmen

Manchmal werden Änderungen in den Quellen nicht übernommen. Dann hilft es den Zeitstempel der Datei python.fcgi mit touch zu aktualisieren:

xyz-doms:~$ touch doms/example.com/fastcgi-ssl/python.fcgi

Alternativ kann der Prozess gestoppt werden:

xyz-doms:~$ ps xaf | grep pyenv | grep -v grep
 7195 ?        Sl     0:01  |   \_ /.../pyenv/bin/python python.fcgi
xyz-doms:~$ kill 7195

oder in einer Zeile:

xyz-doms:~$ kill `ps xaf | grep pyenv | grep -v grep | awk '{print $1}'`

Debuggen einer Anwendung

Wenn es einen Fehler in der Anwendung gibt, oder auch nur schon Syntaxfehler, kann es hilfreich sein, die Anwendung lokal zu starten:

xyz-doms:~$ source pyenv/bin/activate
(pyenv) xyz-doms:~$ python3 doms/example.com/myproject/myproject.py
 * Serving Flask app "myproject" (lazy loading)
 * Environment: production
   WARNING: This is a development server. Do not use it in a production deployment.
   Use a production WSGI server instead.
 * Debug mode: off
 * Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)

Dann wird auf einer anderen Konsole die Abfrage an den Server geschickt:

xyz-doms:~$ curl http://localhost:5000

Nun sieht man auf der ersten Konsole die Ausgabe.

Weiterführende Links

http://rephrase.net/days/08/10/roundup-dreamhost
http://old.nabble.com/lighttpd,-fastcgi-and-roundup-td7752461.html
http://wiki.dreamhost.com/index.php/Python_FastCGI#Using_Flup
http://www.domaincamp.de/support/python
http://code.google.com/p/modwsgi/wiki/QuickConfigurationGuide
http://stackoverflow.com/questions/800584/wsgiserver-errors-when-trying-to-run-django-app
http://code.google.com/p/modwsgi/wiki/IntegrationWithTrac