Por que a configuração DEBUG = False faz com que o acesso estático a arquivos do django falhe?

Estou construindo um aplicativo usando o Django como meu cavalo de batalha. Tudo está bem até agora - configurações de banco de dados especificadas, diretórios estáticos, URLs, visualizações etc. Mas os problemas começaram a surgir no momento em que eu queria renderizar minhas próprias páginas 404.html e 500.html bonitas e personalizadas.

Li os documentos sobre tratamento de erros personalizados e defino as configurações necessárias no UrlsConf, criei as visualizações correspondentes e adicionei o 404.html e o 500.html ao diretório de modelos do meu aplicativo (especificado também em settings.py).

Mas os médicos dizem you can actually view custom error views until Debug is Off, então eu desliguei para testar minhas coisas, e é aí que as coisas ficam loucas!

Não só não consigo visualizar o 404.html personalizado (na verdade, ele carrega, mas porque minhas páginas de erro contêm uma mensagem de erro gráfica - como uma imagem legal), a fonte da página de erro carrega, mas nada mais carrega! Nem mesmo CSS ou Javascript vinculado!

Geralmente, assim que eu definir DEBUG = False, todas as visualizações serão carregadas, mas qualquer conteúdo vinculado (CSS, Javascript, Imagens, etc.) não será carregado! O que está acontecendo? Falta alguma coisa, relacionada aos arquivos estáticos e à DEBUGconfiguração?

Com a depuração desativada, o Django não manipulará mais os arquivos estáticos - seu servidor Web de produção (Apache ou algo assim) deve cuidar disso.

Se você ainda precisa servidor estático localmente (por exemplo, para testar sem depuração), você pode executar o devserver no modo inseguro:

manage.py runserver --insecure

Você pode usar o WhiteNoise para servir arquivos estáticos na produção.

Instalar:

pip install WhiteNoise

E mude seu arquivo wsgi.py para este:

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

application = get_wsgi_application()
application = DjangoWhiteNoise(application)

E você está pronto para ir!

Crédito para o Guiador Creative Blog .

MAS, não é realmente recomendável exibir arquivos estáticos dessa maneira na produção. Seu servidor web de produção (como o nginx) deve cuidar disso.

Em urls.py, adicionei esta linha:

from django.views.static import serve 

adicione esses dois URLs nos padrões de URL:

url(r'^media/(?P<path>.*)$', serve,{'document_root': settings.MEDIA_ROOT}), 
url(r'^static/(?P<path>.*)$', serve,{'document_root': settings.STATIC_ROOT}), 

e os arquivos estáticos e de mídia eram acessíveis quando DEBUG = FALSE.
Espero que ajude :)

Se você estiver usando a exibição estática de veiculação em desenvolvimento, precisará DEBUG = True:

Atenção

Isso funcionará apenas se DEBUG for True.

Isso ocorre porque essa visão é grosseiramente ineficiente e provavelmente insegura. Isso é destinado apenas ao desenvolvimento local e nunca deve ser usado na produção.

Documentos: servindo arquivos estáticos em desenvolvedores

EDIT: você pode adicionar alguns URLs apenas para testar seus modelos 404 e 500, basta usar a visualização genérica direct_to_template em seus URLs.

from django.views.generic.simple import direct_to_template

urlpatterns = patterns('',
    ('^404testing/$', direct_to_template, {'template': '404.html'})
)

A resposta de Johnny é ótima, mas ainda não funcionou para mim apenas adicionando as linhas descritas lá. Com base nessa resposta, as etapas que realmente funcionaram para mim onde:

1. Instale o WhiteNoise conforme descrito:

   pip install WhiteNoise

2. Crie a STATIC_ROOTvariável e adicione WhiteNoise à sua MIDDLEWAREvariável em settings.py:

   #settings.py
   MIDDLEWARE = [
       'django.middleware.security.SecurityMiddleware',
       'whitenoise.middleware.WhiteNoiseMiddleware', #add whitenoise
       'django.contrib.sessions.middleware.SessionMiddleware',
       ...
   ]
   
   #...
   
   STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles') ##specify static root

3. Em seguida, modifique seu wsgi.pyarquivo conforme explicado na resposta de Johnny:

   #wsgi.py
   from django.core.wsgi import get_wsgi_application
   from whitenoise.django import DjangoWhiteNoise
   
   application = get_wsgi_application()
   application = DjangoWhiteNoise(application)

4. Depois disso, implante suas alterações no servidor (com git ou o que você usar).

5. Por fim, execute a collectstaticopção manage.pyno seu servidor. Isso copiará todos os arquivos de suas pastas estáticas no STATIC_ROOTdiretório especificado anteriormente:

   $ python manage.py collectstatic

   Você verá uma nova pasta chamada staticfilesque contém esses elementos.

Depois de seguir estas etapas, você poderá executar o servidor e poderá ver seus arquivos estáticos no modo de produção.

Update: No caso de você tinha a versão <4 o changelog indica que ele não é mais necessário declarar o WSGI_APPLICATION = 'projectName.wsgi.application'no seu settings.pyarquivo.

Você pode realmente servir arquivos estáticos em um aplicativo Django de produção, com segurança e sem DEBUG=True.

Em vez de usar o próprio Django, use dj_static no seu arquivo WSGI ( github ):

# requirements.txt:

...
dj-static==0.0.6


# YOURAPP/settings.py:

...
STATIC_ROOT = 'staticdir'
STATIC_URL = '/staticpath/'

# YOURAPP/wsgi.py:

...
from django.core.wsgi import get_wsgi_application
from dj_static import Cling

application = Cling(get_wsgi_application())

Basta abrir o projeto urls.py e, em seguida, encontre esta instrução if.

if settings.DEBUG:
    urlpatterns += patterns(
        'django.views.static',
        (r'^media/(?P<path>.*)','serve',{'document_root': settings.MEDIA_ROOT}), )

Você pode alterar o settings.DEBUG em True e ele sempre funcionará. Mas se o seu projeto é algo sério, você deve pensar em outras soluções mencionadas acima.

if True:
    urlpatterns += patterns(
        'django.views.static',
        (r'^media/(?P<path>.*)','serve',{'document_root': settings.MEDIA_ROOT}), )

No django 1.10, você pode escrever assim:

urlpatterns += [ url(r'^media/(?P<path>.*)$', serve, { 'document_root': settings.MEDIA_ROOT, }), url(r'^static/(?P<path>.*)$', serve, { 'document_root': settings.STATIC_ROOT }), ]

Você pode depurar isso de várias maneiras diferentes. Aqui está a minha abordagem.

localsettings.py:

DEBUG = False
DEBUG404 = True

urls.py:

from django.conf import settings
import os

if settings.DEBUG404:
    urlpatterns += patterns('',
        (r'^static/(?P<path>.*)$', 'django.views.static.serve',
         {'document_root': os.path.join(os.path.dirname(__file__), 'static')} ),
    )

Certifique-se de ler os documentos;)

https://docs.djangoproject.com/en/2.0/howto/static-files/#limiting-use-to-debug-true

O suporte a argumentos de exibição de string para url () está obsoleto e será removido no Django 1.10

Minha solução é apenas uma pequena correção para a solução Conrado acima.

from django.conf import settings
import os
from django.views.static import serve as staticserve

if settings.DEBUG404:
    urlpatterns += patterns('',
        (r'^static/(?P<path>.*)$', staticserve,
            {'document_root': os.path.join(os.path.dirname(__file__), 'static')} ),
        )

Embora não seja mais seguro, você pode alterar o código fonte. navegar paraPython/2.7/site-packages/django/conf/urls/static.py

Em seguida, edite da seguinte forma:

if settings.DEBUG or (prefix and '://' in prefix):

Portanto, se settings.debug==Falsenão tiver efeito no código, também após a execução, tente python manage.py runserver --runserverexecutar arquivos estáticos.

NOTA : As informações devem ser usadas apenas para teste apenas

Fiz as seguintes alterações no meu projeto / urls.py e funcionou para mim

Adicione esta linha: de django.conf.urls import url

e adicione: url (r '^ media / (? P. *) $', serve, {'document_root': settings.MEDIA_ROOT,}), em urlpatterns.