How to make Django serve static files with Gunicorn?

Answer #1:

When in development mode and when you are using some other server for local development add this to your url.py

from django.contrib.staticfiles.urls import staticfiles_urlpatterns

# ... the rest of your URLconf goes here ...

urlpatterns += staticfiles_urlpatterns()

More info here

When in production you never, ever put gunicorn in front. Instead you use
a server like nginx which dispatches requests to a pool of gunicorn workers and also serves the static files.

See here

Answer #2:

Whitenoise

Post v4.0

http://whitenoise.evans.io/en/stable/changelog.html#v4-0

The WSGI integration option for Django (which involved editing wsgi.py) has been removed. Instead, you should add WhiteNoise to your middleware list in settings.py and remove any reference to WhiteNoise from wsgi.py. See the documentation for more details.
(The pure WSGI integration is still available for non-Django apps.)

Pre v4.0

Heroku recommends this method at: https://devcenter.heroku.com/articles/django-assets:

Your application will now serve static assets directly from Gunicorn in production. This will be perfectly adequate for most applications, but top-tier applications may want to explore using a CDN with Django-Storages.

Install with:

pip install whitenoise
pip freeze > requirements.txt

wsgi.py:

import os
from django.core.wsgi import get_wsgi_application
from whitenoise.django import DjangoWhiteNoise

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "free_books.settings")
application = get_wsgi_application()
application = DjangoWhiteNoise(application)

Tested on Django 1.9.

Answer #3:

The gunicorn should be used to serve the python “application” itself, while the static files are served by a static file server ( such as Nginx ).

There is a good guide here: http://honza.ca/2011/05/deploying-django-with-nginx-and-gunicorn

This is an excerpt from one of my configurations:

upstream app_server_djangoapp {
    server localhost:8000 fail_timeout=0;
}

server {
    listen < server port goes here >;
    server_name < server name goes here >;

    access_log  /var/log/nginx/guni-access.log;
    error_log  /var/log/nginx/guni-error.log info;

    keepalive_timeout 5;

    root < application root directory goes here >;

    location /static {    
        autoindex on;    
        alias < static folder directory goes here >;    
    }

    location /media {
       autoindex on;
       alias < user uploaded media file directory goes here >;
    }

    location / {
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $http_host;
        proxy_redirect off;

        if (!-f $request_filename) {
            proxy_pass http://app_server_djangoapp;
            break;
        }
    }
}

Some notes:

• The static root, media root, static files path prefix and media file path prefix are set up in your settings.py
• Once you have nginx set up to serve from the static content directory, you need to run “python manage.py collectstatic” in your project root so that the static files in the various apps can be copied to the static folder

In closing: while it is possible to serve static files from gunicorn ( by enabling a debug-only static file serving view ), that is considered bad practice in production.

Answer #4:

I’ve used this for my development environment (which uses gunicorn):

from django.conf import settings
from django.contrib.staticfiles.handlers import StaticFilesHandler
from django.core.wsgi import get_wsgi_application


if settings.DEBUG:
    application = StaticFilesHandler(get_wsgi_application())
else:
    application = get_wsgi_application()

And then run gunicorn myapp.wsgi. This works similar to @rantanplan’s answer, however, it does not run any middleware when running static files.

Answer #5:

In order to serve static files, as Jamie Hewland says, normally one routes all the requests to /static/ using Nginx

location /statis/ {

    alias /path/to/static/files;

}

In other words, and as coreyward says about Gunicorn / Unicorn

was not designed to solve the suite of problems involved in serving
files to clients

Same line of reasoning applies if you consider other WSGI server like uWSGI instead of Gunicorn. In uWSGI documentation

it’s inefficient to serve static files via uWSGI. Instead, serve them
directly from Nginx and completely bypass uWSGI

The easier way is to serve your static files with Python using WhiteNoise library which is very easy to setup (you might want to use a CDN so that most requests won’t reach the Python app). As Miguel de Matos says, you just have to

1. Collect static

   python manage.py collectstatic
   

2. Installing whitenoise

   pip install whitenoise
   

3. Add the following STATICFILES_STORAGE in settings.py

   STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'
   

4. Add the following to your MIDDLEWARE in settings.py

   `MIDDLEWARE = [
     'whitenoise.middleware.WhiteNoiseMiddleware',
     'django.middleware.security.SecurityMiddleware',
     ...
   ]
   

Answer #6:

Since Django 1.3 there is django/conf/urls/static.py that handle static files in the DEBUG mode:

from django.conf import settings
from django.conf.urls.static import static

urlpatterns = [
    # ... the rest of your URLconf goes here ...
] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

Read more https://docs.djangoproject.com/en/2.0/howto/static-files/#serving-static-files-during-development