How to make Django serve static files with Gunicorn?

Posted on

Question :

How to make Django serve static files with Gunicorn?

I want to run my django project under gunicorn on localhost. I installed and integrated gunicorn. When I run:

python run_gunicorn

It works but there are no any static files (css and js)

I disabled debug and template_debug in (made them false), but it is still same. Am I missing something?

I call statics like:

{{ STATIC_URL }}css/etc....
Asked By: alix


Answer #1:

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

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

Answered By: alix

Answer #2:


Post v4.0

The WSGI integration option for Django (which involved editing has been removed. Instead, you should add WhiteNoise to your middleware list in and remove any reference to WhiteNoise from 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:

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

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.

Answered By: rantanplan

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:

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;

Some notes:

  • The static root, media root, static files path prefix and media file path prefix are set up in your
  • Once you have nginx set up to serve from the static content directory, you need to run “python 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())
    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.

Answered By: Ngure Nyaga

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;


Nginx + Gunicorn + Django

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 collectstatic
  2. Installing whitenoise

    pip install whitenoise
  3. Add the following STATICFILES_STORAGE in

  4. Add the following to your MIDDLEWARE in

Answered By: WhyNotHugo

Answer #6:

Since Django 1.3 there is django/conf/urls/ 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

Leave a Reply

Your email address will not be published.