FastCGI

    Watch Out

    Please make sure in advance that any calls you might have in your application file are inside an if __name__ == '__main__': block or moved to a separate file. Just make sure it’s not called because this will always start a local WSGI server which we do not want if we deploy that application to FastCGI.

    First you need to create the FastCGI server file. Let’s call it yourapplication.fcgi:

    This is enough for Apache to work, however nginx and older versions of lighttpd need a socket to be explicitly passed to communicate with the FastCGI server. For that to work you need to pass the path to the socket to the WSGIServer:

    1. WSGIServer(application, bindAddress='/path/to/fcgi.sock').run()

    The path has to be the exact same path you define in the server config.

    Save the yourapplication.fcgi file somewhere you will find it again. It makes sense to have that in /var/www/yourapplication or something similar.

    Make sure to set the executable bit on that file so that the servers can execute it:

    1. $ chmod +x /var/www/yourapplication/yourapplication.fcgi

    Configuring Apache

    1. LoadModule fastcgi_module /usr/lib64/httpd/modules/mod_fastcgi.so
    3. FastCgiServer /var/www/html/yourapplication/app.fcgi -idle-timeout 300 -processes 5
    5. <VirtualHost *>
    6.     ServerName webapp1.mydomain.com
    7.     DocumentRoot /var/www/html/yourapplication
    9.     AddHandler fastcgi-script fcgi
    10.     ScriptAlias / /var/www/html/yourapplication/app.fcgi/
    12.     <Location />
    13.         SetHandler fastcgi-script
    14.     </Location>
    15. </VirtualHost>

    These processes will be managed by Apache. If you’re using a standalone FastCGI server, you can use the FastCgiExternalServer directive instead. Note that in the following the path is not real, it’s simply used as an identifier to other directives such as AliasMatch:

    If you cannot set ScriptAlias, for example on a shared web host, you can use WSGI middleware to remove yourapplication.fcgi from the URLs. Set .htaccess:

    1. <IfModule mod_fcgid.c>
    2.    AddHandler fcgid-script .fcgi
    3.    <Files ~ (\.fcgi)>
    4.        SetHandler fcgid-script
    5.        Options +FollowSymLinks +ExecCGI
    6.    </Files>
    7. </IfModule>
    8. <IfModule mod_rewrite.c>
    10.    RewriteEngine On
    11.    RewriteBase /
    12.    RewriteCond %{REQUEST_FILENAME} !-f
    13.    RewriteRule ^(.*)$ yourapplication.fcgi/$1 [QSA,L]
    14. </IfModule>

    Set yourapplication.fcgi:

    1. #!/usr/bin/python
    2. #: optional path to your local python site-packages folder
    3. import sys
    4. sys.path.insert(0, '<your_local_path>/lib/python<your_python_version>/site-packages')
    6. from flup.server.fcgi import WSGIServer
    7. from yourapplication import app
    9. class ScriptNameStripper(object):
    10.    def __init__(self, app):
    11.        self.app = app
    13.    def __call__(self, environ, start_response):
    14.        environ['SCRIPT_NAME'] = ''
    15.        return self.app(environ, start_response)
    17. app = ScriptNameStripper(app)
    19. if __name__ == '__main__':
    20.     WSGIServer(app).run()

    A basic FastCGI configuration for lighttpd looks like that:

    1. fastcgi.server = ("/yourapplication.fcgi" =>
    2.     ((
    3.         "socket" => "/tmp/yourapplication-fcgi.sock",
    4.         "check-local" => "disable",
    5.         "max-procs" => 1
    7. )
    9. alias.url = (
    10.     "/static/" => "/path/to/your/static/"
    11. )
    13. url.rewrite-once = (
    14.     "^(/static($|/.*))$" => "$1",
    15.     "^(/.*)$" => "/yourapplication.fcgi$1"
    16. )

    Remember to enable the FastCGI, alias and rewrite modules. This configuration binds the application to /yourapplication. If you want the application to work in the URL root you have to work around a lighttpd bug with the LighttpdCGIRootFix middleware.

    Make sure to apply it only if you are mounting the application the URL root. Also, see the Lighty docs for more information on (note that explicitly passing a socket to run() is no longer necessary).

    Configuring nginx

    Installing FastCGI applications on nginx is a bit different because by default no FastCGI parameters are forwarded.

    This configuration binds the application to /yourapplication. If you want to have it in the URL root it’s a bit simpler because you don’t have to figure out how to calculate PATH_INFO and SCRIPT_NAME:

    1. location / { try_files $uri @yourapplication; }
    2. location @yourapplication {
    3.     include fastcgi_params;
    4.     fastcgi_param PATH_INFO $fastcgi_script_name;
    5.     fastcgi_param SCRIPT_NAME "";
    6.     fastcgi_pass unix:/tmp/yourapplication-fcgi.sock;
    7. }

    Since nginx and others do not load FastCGI apps, you have to do it by yourself. You can look around for other FastCGI process managers or write a script to run your .fcgi file at boot, e.g. using a SysV init.d script. For a temporary solution, you can always run the .fcgi script inside GNU screen. See man screen for details, and note that this is a manual solution which does not persist across system restart:

    1. $ screen
    2. $ /var/www/yourapplication/yourapplication.fcgi

    Debugging

    FastCGI deployments tend to be hard to debug on most web servers. Very often the only thing the server log tells you is something along the lines of “premature end of headers”. In order to debug the application the only thing that can really give you ideas why it breaks is switching to the correct user and executing the application by hand.

    This example assumes your application is called application.fcgi and that your web server user is www-data:

    1. $ su www-data
    2. $ cd /var/www/yourapplication
    3. $ python application.fcgi
    4. Traceback (most recent call last):
    6. ImportError: No module named yourapplication

    In this case the error seems to be “yourapplication” not being on the python path. Common problems are:

    • Relative paths being used. Don’t rely on the current working directory.

    • The code depending on environment variables that are not set by the web server.