Arquivos estáticos no django 1.3

[willian firmino]

Pessoal, vi que a versão 1.3 do django tem um novo esquema para os
arquivos estaticos, mesmo lendo a documentação não entendi muito bem,
alguem poderia me dar um exemplo de configuração no settings.py e no
urls.py

[Guilherme Kuhn]

Acho que estas configurações serviriam apenas se você estiver utilizando o django com o servidor interno dele (python manager.py runserver)

No caso de usar em produção com um apache ou outro parecido, é melhor deixar o serviço de gerenciamento de arquivos estáticos com ele.

Até por questão de performance da aplicação.

Nunca me aprofundei neste tipo de configuração do django tbm.

--
Django Brasil em Google Groups <http://groups.google.com.br/group/django-brasil>
Associe-se à Python Brasil e suporte nossa comunidade! <http://associacao.python.org.br/>

[willian firmino]

Entendi, valeu guilherme obrigado pela explicação.

[Estêvão]

Em 7 de abril de 2011 15:42, Guilherme Kuhn <g.k...@gmail.com> escreveu:

Acho que estas configurações serviriam apenas se você estiver utilizando o django com o servidor interno dele (python manager.py runserver)

No caso de usar em produção com um apache ou outro parecido, é melhor deixar o serviço de gerenciamento de arquivos estáticos com ele.

Até por questão de performance da aplicação.

Então, pelo o que eu entendi as configurações indicadas na documentação são apenas para se utilizar durante o desenvolvimento e com o servidor local, pois em produção pode oferecer riscos de segurança (não sei exatamente quais riscos... pois acho que se os arquivos forem disponibilizados pelo apache ou outro httpd eles serão publicados da mesma forma; se alguém puder entrar em detalhes eu agradeço).

Eu uso DreamHost e como não tenho acesso às configurações do apache tenho disponibilizado staticfiles via framework mesmo, acho que _não_ existe alternativa em shared hosting... se alguém souber de algo...

Sobre as configurações é tranquilo, se atenha às variáveis STATICROOT e STATICURL no settings.py.

A primeira apontando para o diretório onde você armazenará seus arquivos estáticos:
STATICROOT = '/home/usuario/site/staticfiles'

A segunda definindo a url:
STATICURL = '/static/'
que será http://seusite.com.br/static/

E no urls.py - adicione ao final:

if settings.DEBUG:
    urlpatterns += patterns('django.contrib.staticfiles.views',
        url(r'^static/(?P<path>.*)$', 'serve'),
    )

PS. Para que o código acima funcione o debug tem que ser ativo. Se você quiser desativar o debug (DEBUG = False em settings.py) você precisará comentar a linha (if settings.DEBUG:), assim:

#if settings.DEBUG:
    urlpatterns += patterns('django.contrib.staticfiles.views',
        url(r'^static/(?P<path>.*)$', 'serve'),
    )


Acho que é basicamente isso. Att,

Nunca me aprofundei neste tipo de configuração do django tbm.

Em 7 de abril de 2011 14:38, willian firmino <willian....@gmail.com> escreveu:

Pessoal, vi que a versão 1.3 do django tem um novo esquema para os
arquivos estaticos, mesmo lendo a documentação não entendi muito bem,
alguem poderia me dar um exemplo de configuração no settings.py e no
urls.py

--
Django Brasil em Google Groups <http://groups.google.com.br/group/django-brasil>
Associe-se à Python Brasil e suporte nossa comunidade! <http://associacao.python.org.br/>

--
Django Brasil em Google Groups <http://groups.google.com.br/group/django-brasil>
Associe-se à Python Brasil e suporte nossa comunidade! <http://associacao.python.org.br/>

--
Estêvão Valadão

[Henrique Bastos]

Não é só isso!

O django.contrib.staticfiles fornece uma api bem definida sobre como trabalhar e administrar arquivos estáticos.

Anteriormente, todos os seus arquivos estáticos deveriam ficam em um mesmo lugar no projeto, e não nas Apps. Isso gerava alguns efeitos colaterais, como por exemplo, dificultava a distribuição de Apps que possuíam arquivos estáticos.

Agora a gestão dos arquivos estáticos está mais integrada ao Django e parecida com a gestão dos templates.

Abs,

--

Henrique Bastos

Curso Welcome to the Django

Aprenda Python e Django na Prática!

Twitter: @henriquebastos
Skype: henriquebastos.net

+55 21 9618-6180

2011/4/7 willian firmino <willian....@gmail.com>

[Estêvão]

Em 7 de abril de 2011 16:30, Henrique Bastos <henr...@bastos.net> escreveu:

Não é só isso!

O django.contrib.staticfiles fornece uma api bem definida sobre como trabalhar e administrar arquivos estáticos.

Anteriormente, todos os seus arquivos estáticos deveriam ficam em um mesmo lugar no projeto, e não nas Apps. Isso gerava alguns efeitos colaterais, como por exemplo, dificultava a distribuição de Apps que possuíam arquivos estáticos.

Agora a gestão dos arquivos estáticos está mais integrada ao Django e parecida com a gestão dos templates.

Sim, o padrão sugere que você crie o diretório static/ dentro das apps e que depois execute python manage.py collectstatic, que irá coletar os arquivos estáticos das apps e copiá-los para o diretório que você definiu em seu STATICROOT para serem servidos. No final eles são servidos a partir do mesmo diretório...

--
Estêvão Valadão

[Flávio Correia Lima]

Estêvão, acho que não são riscos de segurança e sim de performance. É mais rápido o Apache (por exemplo) simplesmente retornar o arquivo estático diretamente sem passar pelo Django do que deixar as requisições de arquivos estáticos para serem tratadas pelo Django.

Abraço


Flávio Correia Lima
flaviocorreialima.com

[willian firmino]

Tudo bem e como fica o MEDIA_ROOT e o MEDIA_URL ?
não preciso usar mais ?

Em 7 de abril de 2011 17:57, Flávio Correia Lima
<flavio.co...@gmail.com> escreveu:

[willian firmino]

pelo que entendi MEDIA_ROOT e o MEDIA_URL são para serem usados por
arquivos enviados pelos usuarios.

Em 8 de abril de 2011 07:58, willian firmino
<willian....@gmail.com> escreveu:

[Henrique Bastos]

Estêvão,

Na Dreamhost é sim possível servir os arquivos estáticos sem passar pelo Django.

Quando você configura um domínio com suporte à Django, você define um "diretório raiz" para sua aplicação. Geralmente ~/nome_do_dominio/public_html. Tudo o que estiver neste diretório é servido diretamente sem passar pelo Django.

Abraços,

--

Henrique Bastos

Curso Welcome to the Django

Aprenda Python e Django na Prática!

Twitter: @henriquebastos
Skype: henriquebastos.net

+55 21 9618-6180

2011/4/7 Estêvão <estev...@gmail.com>

[Júlio Max]

O que eu prefiro é adquirir uma vps em conta, configurar um nginx+gevent

Não acham melhor que ficar sob as limitações dos planos de hospedagem?

Tenho usado assim e a performance é excelente, o consumo de memória é muito baixo...

Já vi até vps de 6dolares (burst.net) mas não testei ainda... vou testar semana que vem.

Uso dedicadosbr... vps de 26reais

 

Valeu

---

From: Henrique Bastos <henr...@bastos.net>
To: django...@googlegroups.com
Cc: Estêvão <estev...@gmail.com>
Sent: Fri, April 8, 2011 3:12:27 PM
Subject: Re: Arquivos estáticos no django 1.3

[CarlosH]

eu também estou com dúvida em relação a isso.
antes usava aqui nos meus projetos uma pasta '/static' para os
arquivos estáticos e os enviados pelo admin.
pelo q eu entendi agora tenho q criar uma pasta somente para os
estáticos e deixar a '/static' para os arquivos dinâmicos.
ai criei a pasta '/staticfiles' e joguei meus arquivos lá.

meu settings ficou assim:

MEDIA_ROOT = os.path.join(PROJECT_PATH, 'static')
MEDIA_URL = '/static/'
STATIC_URL = '/staticfiles/'
STATIC_ROOT = os.path.join(PROJECT_PATH, 'staticfiles')

e no meu urls ta assim.
if settings.DEBUG:
urlpatterns += patterns('',
(r'^staticfiles/(?P<path>.*)$', 'django.views.static.serve',
{'document_root': settings.STATIC_ROOT, 'show_indexes':
True}),
(r'^static/(?P<path>.*)$', 'django.views.static.serve',
{'document_root': settings.MEDIA_ROOT, 'show_indexes':
True}),
)

ai nos htmls qd tem os arquivos estaticos como o {{STATIC_URL}}
e nos dinamicos {{MEDIA_URL}}

soh q quando inicio o servidor local com python manage.py runserver os
arquivos q tem o {{STATIC_URL}} não aparecem mas os com {{MEDIA_URL}}
aparecem normal.
mas vendo no site do django tem o paramento --nostatic. coloquei ele
no python manage.py runserver --nostatic e aparece tudo normal.
se alguem pudesse esclarecer melhor isso...

On Apr 9, 11:44 pm, Júlio Max <juliom...@yahoo.com> wrote:
> O que eu prefiro é adquirir uma vps em conta, configurar um nginx+gevent
> Não acham melhor que ficar sob as limitações dos planos de hospedagem?
> Tenho usado assim e a performance é excelente, o consumo de memória é muito
> baixo...
> Já vi até vps de 6dolares (burst.net) mas não testei ainda... vou testar semana
> que vem.
> Uso dedicadosbr... vps de 26reais
>
> Valeu
>
> ________________________________

> From: Henrique Bastos <henri...@bastos.net>
> To: django...@googlegroups.com
> Cc: Estêvão <estevao...@gmail.com>

> Sent: Fri, April 8, 2011 3:12:27 PM
> Subject: Re: Arquivos estáticos no django 1.3
>
> Estêvão,
>
> Na Dreamhost é sim possível servir os arquivos estáticos sem passar pelo Django.
>
> Quando você configura um domínio com suporte à Django, você define um "diretório
> raiz" para sua aplicação. Geralmente ~/nome_do_dominio/public_html. Tudo o que
> estiver neste diretório é servido diretamente sem passar pelo Django.
>
> Abraços,

> --Henrique Bastos

>
> Curso Welcome to the Django
> Aprenda Python e Django na Prática!
>
> Twitter: @henriquebastos
> Skype: henriquebastos.net
>
> +55 21 9618-6180
>

> 2011/4/7 Estêvão <estevao...@gmail.com>

>
>
>
>
>
> >Em 7 de abril de 2011 16:30, Henrique Bastos <henri...@bastos.net> escreveu:
>
> >Não é só isso!
>
> >>O django.contrib.staticfiles fornece uma api bem definida sobre como trabalhar e
> >>administrar arquivos estáticos.
>
> >>Anteriormente, todos os seus arquivos estáticos deveriam ficam em um mesmo lugar
> >>no projeto, e não nas Apps. Isso gerava alguns efeitos colaterais, como por
> >>exemplo, dificultava a distribuição de Apps que possuíam arquivos estáticos.
>
> >>Agora a gestão dos arquivos estáticos está mais integrada ao Django e parecida
> >>com a gestão dos templates.
>
> >Sim, o padrão sugere que você crie o diretório static/ dentro das apps e que
> >depois execute python manage.py collectstatic, que irá coletar os arquivos
> >estáticos das apps e copiá-los para o diretório que você definiu em seu
> >STATICROOT para serem servidos. No final eles são servidos a partir do mesmo
> >diretório...
>
> >>Abs,
> >>--
> >>Henrique Bastos
>
> >>Curso Welcome to the Django
> >>Aprenda Python e Django na Prática!
>
> >>Twitter: @henriquebastos
> >>Skype: henriquebastos.net
>
> >>+55 21 9618-6180
>

> >>2011/4/7 willian firmino <willian.firmi...@gmail.com>

>
> >>Entendi, valeu guilherme obrigado pela explicação.
>

> >>>Em 7 de abril de 2011 15:42, Guilherme Kuhn <g.ku...@gmail.com> escreveu:
>
> >>>> Acho que estas configurações serviriam apenas se você estiver utilizando o
> >>>> django com o servidor interno dele (python manager.py runserver)
> >>>> No caso de usar em produção com um apache ou outro parecido, é melhor
> deixar
> >>>> o serviço de gerenciamento de arquivos estáticos com ele.
> >>>> Até por questão de performance da aplicação.
> >>>> Nunca me aprofundei neste tipo de configuração do django tbm.
>

> >>>> Em 7 de abril de 2011 14:38, willian firmino <willian.firmi...@gmail.com>

[willian firmino]

eu também estou parado neste ponto exatamente igual a você

[Rodrigo Chacon]

Bom, seguindo a documentação do Django [1], funciona da seguinte forma:

Os seus arquivos estáticos ficarão nos apps, ou em pastas externas que você desejar, mas não devem NUNCA ser adicionados manualmente a pasta static do projeto. Quando houver qualquer mudança nos arquivos você deve rodar o comando "collectstatic" que irá buscar todos os seus arquivos estáticos.

Para seguir a estrutura recomendada, mude suas pastas para o seguinte:

/static/ - Crie esta pasta e deixe-a vazia

/media/ - Esta pasta será usada para guardar os arquivos que os usuários enviarão (upload)

1. Configurando os caminhos:

settings.py:

MEDIA_ROOT = os.path.join(PROJECT_PATH, 'media')

MEDIA_URL = '/media/'

STATIC_ROOT = os.path.join(PROJECT_PATH, 'static')

STATIC_URL = '/static/'

STATICFILES_DIRS = (

    # Aqui vão as pastas que contém arquivos estáticos que não pertencem a nenhum de seus apps

)

STATICFILES_FINDERS = (

    'django.contrib.staticfiles.finders.FileSystemFinder',

    'django.contrib.staticfiles.finders.AppDirectoriesFinder',

)

ADMIN_MEDIA_PREFIX = '/static/admin/'

OBS: Se você usa um TEMPLATE_CONTEXT_PROCESSORS personalizado, verifique se possue as seguintes entradas:

'django.core.context_processors.media'

e

'django.core.context_processors.static'

Isso garantirá que nos seus templates você possa acessar os arquivos usando as variáveis STATIC_URL e MEDIA_URL. [3]

2. Agora, dentro dos seus apps você irá criar uma pasta "static" e irá guardar lá os respectivos arquivos estáticos, ex.

app: index:

/projeto

- /index

-- /static

--- /img

---- /test.jpg

ou: /projeto/index/static/img/test.jpg

ou: /projeto/index/static/index/img/test.jpg (para melhor organização, veja o resultado final)

Depois de configurados os caminhos, você precisa configurar as URLs para servi-los em desenvolvimento (servir arquivos estáticos com o Django em produção é extremamente desaconselhado [2], use seu servidor web [Apache, nginx, etc.])

3. Adicione ao final do arquivo: urls.py

from django.conf import settings

from django.conf.urls.static import static

from django.contrib.staticfiles.urls import staticfiles_urlpatterns

if settings.DEBUG:

    urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT) # Arquivos enviados pelo usuário

    urlpatterns += staticfiles_urlpatterns() # NUNCA use em produção, veja [2]

Depois disso os seus arquivos estáticos ainda não estão sendo servidos pelo Django (os da pasta /media/ funcionam).

Você precisa rodar o comando a seguir, para que o Django busque seus arquivos estáticos e os coloque na pasta static, só assim eles serão servidos:

$ python manage.py collectstatic

OBS: cuidado, este comando irá substituir os arquivos estáticos já existentes.

Com esse "comando mágico" todos os seus arquivos estáticos estarão agora na pasta static e sendo servidos pelo Django.

Desculpe pelo longo texto, não tinha como resumir mais... =/

-- Rodrigo Chacon

[1] http://docs.djangoproject.com/en/1.3/howto/static-files/

[2] http://docs.djangoproject.com/en/1.3/howto/static-files/#serving-static-files-in-development

[3] http://docs.djangoproject.com/en/1.3/howto/static-files/#referring-to-static-files-in-templates

[Adauto Serpa]

Pessoal,

Também estava com dificuldades de entender a configuração do STATIC_FILES.
Pelo que eu li e entendi a configuração STATIC_ROOT serve para coletar os arquivos estáticos e copiá-los.
Pra mim isso por enquanto não vai ter tão funcional, pois estou montando a aplicação e copiando manualmente meus arquivos para
meu_projeto/static.

Segue a minha composição dos diretórios do meu projeto para armazenar os arquivos estáticos.

meu_projeto
             |____static
                         |____js
                         |____css
                         |____img

Arquivo settings:

STATIC_ROOT = ''
STATIC_URL = '/static/'
STATICFILES_DIRS = (os.path.join(PROJECT_ROOT_PATH, 'static'),)

Agora referenciando num template:

<link rel="stylesheet" type="text/css" href="{{ STATIC_URL }}css/layout.css" />
<img src="{{ STATIC_URL }}img/foto.jpg" />

Dentro de um css:

body{ background-image: url('../img/bg.jpg') }

Bom é assim que estou usando e está funcionando, deixei o diretório MEDIA para uso de arquivos que

interajam diretamente com o usuário.

Bom acredito que estou usando as melhores práticas e seguindo a documentação do Django.

Agora uma observação referente a url na hospedagem, por exemplo quando for configurar o acesso a sua aplicação

em num endereço tipo www.dominio.com.br/blog os endereços deverão se colocados com o nome da aplicação + o diretório STATIC

<link href="{{ STATIC_URL }}blog/static/css/layout.css">

Porém isso é muito relevante, pois o pessoal da lista e acredito que a documentação também afirme isso, que os arquivos estáticos

devem ser hospedados num servidor web para melhor desempenho.

Desculpe também meu texto longo não consegui resumir mais. Só tenho uma dúvida graças a Deus ! Como é melhor servir uma aplicação

com subdomínio(app.dominio.com.br) ou dominio/aplicação(www.dominio.com.br/app) ?

Particularmente estou preferindo com subdomínio, menos trabalho na hora de fazer o deploy, url mais limpa e adotando um projeto por subdomínio

o que vocês acham ?

É que dependendo dos casos tenho que ajustar endereços em diversos arquivos por isso minha dúvida.

att.

Adauto Serpa

[Rodrigo Chacon]

Adauto, eu prefiro sub-dominios. Acho que fica mais limpa a url.

No caso de usar uma pasta (como no ex. do blog: exemplo.com/blog/), você pode adicionar o '/blog/' no inicio da STATIC_URL e assim não precisará modificar todos os templates.

-- Rodrigo Chacon

[Adauto Serpa]

Boa Rodrigo,

Que burro eu... dá zero pra mim... rsrsrs

Coisa simples, mas de grande ajuda.

valeu Rodrigo.

Adauto Serpa 

[Cássio Nandi Citadin]

Pessoal, desculpem ressucitar o tópico, mas mesmo lendo a documentação e a discussão de vcs aqui eu ainda não estou satisfeito.

Segundo a documentação:
This view is automatically enabled and will serve your static files at STATIC_URL when you use the built-in runserver management command.

Ou seja, quem usa runserver já deveria sair com tudo funcionando, e não é o caso, tem essa qtde grande configurações pra quem ta desenvolvendo, e ainda no meu caso nem tudo isso funcionou (não faço idéia do pq ainda). Pelo que ta escrito lá na doc, nem precisaria mexer no url.py, a não ser que fosse num servidor difernte do built-in do django.

Até gostei da forma como foi separado o media do static, conceitualmente ao menos, a coisa toda de distribuir os statics dentro da app ficou bonito tb, prático pra distribuição. Porém, se eu quero apenas fazer uma simplória imagem aparecer na tela inicial (sem criar nenhuma app, nem coletar os statics). To achando burocrático demais, ou to errado?

Cordialmente,
   Cássio Nandi Citadin  -  cassionandi at gmail.com
   @cassionandi  -  http://cassionandi.blogspot.com
   (48) 9921-9991

Não basta ser agora, tem que ser pra Jah!

[Cássio Nandi Citadin]

Detalhe, quando eu uso o collectstatics, ele puxa os statics do admin o_O

[Cássio Nandi Citadin]

Okay, agora avancei um pouco dos estudos.

Configurei o settings pra ver meu diretório static (geral, deretamente abaixo da pasta do projeto).
Ficou assim o settings

MEDIA_ROOT = os.path.join(SITE_ROOT, 'media')
MEDIA_URL = '/media/'
STATIC_ROOT = os.path.join(SITE_ROOT, 'static')
STATIC_URL = '/static/'
STATICFILES_DIRS = ()
ADMIN_MEDIA_PREFIX = '/static/admin/'

Criei uma app chamada app1 e adicionei no INSTALLED_APPS e testei o collectstatic. Antes só puxava os static do admin pq era a única app com pasta static instalada (que burro da zero pra mim ehhehe)

No url.py fiz absolutamente NADA, apesar das dicas de adicionar várias coisas.
No template fiz a chamada padrão

<img src="{{STATIC_URL}}img/foto.jpg"/>

Enfim, sou um desenvolvedor Django FELIZ agora =D

[Cássio Nandi Citadin]

Okay, agora regredi no entendimento.

Acabei de notar que meus arquivos estão sendo pegos de dentro das apps, não da pasta do projeto como achei que havia configurado.
Sou obrigado a ter um diretorio /static/ dentro de cada app?
Não é possível ter um diretório de statics geral no projeto?

(falando em ambiente de desenvolvimento)

[Robson]

Em 9 de maio de 2011 21:33, Cássio Nandi Citadin
<cassi...@gmail.com> escreveu:

> Okay, agora regredi no entendimento.
>
> Acabei de notar que meus arquivos estão sendo pegos de dentro das apps, não
> da pasta do projeto como achei que havia configurado.
> Sou obrigado a ter um diretorio /static/ dentro de cada app?
> Não é possível ter um diretório de statics geral no projeto?
>
> (falando em ambiente de desenvolvimento)

> [cut]

Olá Cassio,

Ainda não usei isso, mas pelo o que entendi lendo a documentação, a
idéia é exatamente essa: pegar os arquivos estáticos que estão dentro
das pastas das suas apps e copiá-los p/ a pasta que vc definiu no
settings.

Acho que o objetivo é deixar as aplicações mais "plugáveis", onde cada
app pode ter seus próprios arquivos estáticos e eles são copiados p/ o
local certo através do comando collectstatic.

abs!

[Israel Ben Guilherme Fonseca]

O problema no caso dele robson é que:

Em desenvolvimento, os arquivos não estão sendo lidos do STATIC_ROOT, mas sim das pastas static dentro de cada APP, o que é estranho porque na minha cabeça em desenvolvimento ele deveria tentar ler dos DOIS lugares.

--

[Cássio Nandi Citadin]

Verdade. Por exemplo, se eu quiser apenas estruturar o design do projeto, não tenho app nem nada, só a página inicial. Ainda assim vou ter que criar uma app pra guardar os statics?

E onde é definido o nome da pasta de statics como static?

[Felipe Zorzo]

Em 9 de maio de 2011 21:33, Cássio Nandi Citadin <cassi...@gmail.com> escreveu:

Okay, agora regredi no entendimento.

Acabei de notar que meus arquivos estão sendo pegos de dentro das apps, não da pasta do projeto como achei que havia configurado.
Sou obrigado a ter um diretorio /static/ dentro de cada app?
Não é possível ter um diretório de statics geral no projeto?

(falando em ambiente de desenvolvimento)

Em 10 de maio de 2011 08:41, Cássio Nandi Citadin <cassi...@gmail.com> escreveu:

Verdade. Por exemplo, se eu quiser apenas estruturar o design do projeto, não tenho app nem nada, só a página inicial. Ainda assim vou ter que criar uma app pra guardar os statics?

E onde é definido o nome da pasta de statics como static?

Ok, vamos lá (explicação longa e sem tl;dr).

http://docs.djangoproject.com/en/1.3/howto/static-files/#using-django-contrib-staticfiles

No servidor de desenvolvimento, os arquivos *não* são lidos do STATIC_ROOT, justamente pra você não precisar ficar rodando o collectstatic toda vez que alterar um arquivo estático. Os  arquivos são lidos das pastas "static/" dentro das apps *e* dos caminhos configurados no STATICFILES_DIRS. Se você quiser criar arquivos estáticos do projeto, é só criar uma pasta no projeto e adicionar ela no STATICFILES_DIRS.

O STATIC_ROOT é ignorado pelo servidor de desenvolvimento. Ele é apenas o local para onde os arquivos estáticos serão copiados para facilitar a configuração do projeto em ambiente de produção.

Exemplo: imagine uma aplicação que tem um CSS próprio, mas compartilha com todo o projeto uma biblioteca javascript (os arquivos estáticos seriam, por exemplo, style.css e lib.js). Pra permitir isso, eu posso criar uma pasta "static" na app e colocar o .css e uma pasta chamada, por exemplo, "static" (não é obrigatório usar esse nome aqui) no *projeto*. A estrutura de arquivos seria assim:

meuprojeto/

-- minhaapp/static/style.css

-- static/lib.js

No settings.py, basta configurar o STATICFILES_DIRS, com o static do projeto (o static da app é automático):

STATICFILES_DIRS = (

    '/caminho/do/meuprojeto/static',

)

Só isso já é suficiente para os arquivos estáticos funcionarem no servidor de desenvolvimento. Todos os arquivos estáticos ficarão acessíveis no caminho definido no STATIC_URL.

Para a produção (rodando o collectstatic), é necessário configurar o STATIC_ROOT. Daria pra criar uma pasta "sitestatic" no projeto e configurar: STATIC_ROOT = '/caminho/do/meuprojeto/sitestatic'. Ao rodar o collectstatic, o resultado seria:

meuprojeto/

-- minhaapp/static/style.css

-- static/lib.js

-- sitestatic/style.css (arquivo coletado)

-- sitestatic/lib.js (arquivo coletado)

Aí é configurar um servidor pra servir os arquivos estáticos dessa pasta (STATIC_ROOT), no caminho configurado (STATIC_URL) e correr pro abraço.

--
Felipe Bernardo Zorzo (@felipez)

http://www.felipezorzo.com.br

[Cássio Nandi Citadin]

Felipe, muito obrigado, você sanou as dúvidas. Abraço!

--
Django Brasil em Google Groups <http://groups.google.com.br/group/django-brasil>
Associe-se à Python Brasil e suporte nossa comunidade! <http://associacao.python.org.br/>

[Lucas Rezende]

Pelo que eu entendi, o MEDIA_ROOT é o diretório que armazanará os arquivos de usuários (ex.: upload de foto). O MEDIA_URL é o caminho para o MEDIA_ROOT.

Ex.: 

MEDIA_URL='/media/'

Se digitar  www.site.com.br/media/ você vai apontar para o que estiver em MEDIA_ROOT, o que torna os arquivos de upload públicos.

Por favor, me corrigam se eu estiver errado pois não estou certo e gostaria de entender 100% também.

Quanto ao STATIC_ROOT, se eu entendi, é um diretório utilizado pelo Django onde ele move temporariamente o que estiver em STATIC_URL para que possa realizar o processamento. 

Novamente, por favor me corrigam se eu estiver errado pois não estou certo e gostaria de entender 100% também.

[Robson]

Em 18 de maio de 2011 16:44, Lucas Rezende <lucas...@gmail.com> escreveu:
> Pelo que eu entendi, o MEDIA_ROOT é o diretório que armazanará os arquivos
> de usuários (ex.: upload de foto). O MEDIA_URL é o caminho para o
> MEDIA_ROOT.
> Ex.:
> MEDIA_URL='/media/'
> Se digitar  www.site.com.br/media/ você vai apontar para o que estiver em
> MEDIA_ROOT, o que torna os arquivos de upload públicos.
>

Olá Lucas,

É praticamente isso... a única coisa é que o django não irá mapear
automaticamente essa url definida em MEDIA_URL, vc precisa configurar
isso manualmente em seu servidor (nginx, apache, lighttp, etc..) ou no
seu urls.py, caso use o django.views.static.serve.

No MEDIA_URL vc pode inclusive colocar um link direto apontando pra um
subdomínio ou até outro domínio qualquer (e.g.
http://static.example.com/).

Resumindo, o MEDIA_URL serve apenas pra fins de organização do
projeto, permitindo que vc use ele em seus templates e não precise
alterar o template caso a url dos seus arquivos estáticos mude.

abs!
Robson

[Lucas Rezende]

Só para complementar, pelo que eu li na documentação, se você
especificar o STATIC_URL='/static/' (por exemplo), ele pega o que
estiver na pasta "static" do projeto e varre as pastas das apps a
procura desse diretório. Quando ele encontra, ele move os arquivo que
estão dentro para o diretório especificado no STATIC_ROOT para tornar
mais fácil a execução.

Caso esteja errado, de novo, por favor me corrigam! hehehe

Abraço!

On May 18, 4:44 pm, Lucas Rezende <lucasgr...@gmail.com> wrote:
> Pelo que eu entendi, o MEDIA_ROOT é o diretório que armazanará os arquivos
> de usuários (ex.: upload de foto). O MEDIA_URL é o caminho para o
> MEDIA_ROOT.
>
> Ex.:
> MEDIA_URL='/media/'

> Se digitar *www.site.com.br/media/*você vai apontar para o que estiver em
> *MEDIA_ROOT*, o que torna os arquivos de upload públicos.

[Lucas Rezende]

Agora para eu mesmo me corrigir, me corriJam é com J! HEHE

On May 18, 5:00 pm, Lucas Rezende <lucasgr...@gmail.com> wrote:
> Só para complementar, pelo que eu li na documentação, se você
> especificar o STATIC_URL='/static/' (por exemplo), ele pega o que
> estiver na pasta "static" do projeto e varre as pastas das apps a
> procura desse diretório. Quando ele encontra, ele move os arquivo que
> estão dentro para o diretório especificado no STATIC_ROOT para tornar
> mais fácil a execução.
>
> Caso esteja errado, de novo, por favor me corrigam! hehehe
>
> Abraço!
>
> On May 18, 4:44 pm, Lucas Rezende <lucasgr...@gmail.com> wrote:
>
>
>
>
>
>
>
> > Pelo que eu entendi, o MEDIA_ROOT é o diretório que armazanará os arquivos
> > de usuários (ex.: upload de foto). O MEDIA_URL é o caminho para o
> > MEDIA_ROOT.
>
> > Ex.:
> > MEDIA_URL='/media/'

> > Se digitar *www.site.com.br/media/*vocêvai apontar para o que estiver em

[Valder Gallo]

Lucas, te explicar sobre os novos componentes do static do Django.

Meu settings:

import os
BASEDIR = os.path.abspath(os.path.dirname(__file__) + '../../..')

STATIC_ROOT = BASEDIR + '/static/'
STATIC_URL = '/static/'

MEDIA_ROOT = BASEDIR + '/media/'

#ADMIN_MEDIA_PREFIX = STATIC_URL + "admin_media/"
ADMIN_MEDIA_PREFIX = STATIC_URL + "grappelli/"
#Aqui eu estou utilizando o grappelli no admin

# Additional locations of static files
STATICFILES_DIRS = (
("downloads", "/opt/webfiles/stats"),
#<a href="{{ STATIC_URL }}downloads/polls_20101022.tar.gz">
("video", "/opt/webfiles/videos"),
#<a href="{{ STATIC_URL }}video/flynn.flv">
#Com o novo static file vc consegue criar links de diret�rios
)

#List of finder classes that know how to find static files in
# various locations.

STATICFILES_FINDERS = (
'django.contrib.staticfiles.finders.FileSystemFinder',
'django.contrib.staticfiles.finders.AppDirectoriesFinder',

'django.contrib.staticfiles.finders.DefaultStorageFinder',
)

TEMPLATE_CONTEXT_PROCESSORS = (
'django.core.context_processors.debug',
'django.core.context_processors.i18n',
'django.core.context_processors.static',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
)

Meu template:

{% load static %}
{% get_static_prefix as STATIC_PREFIX %}

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset='UTF-8' />
{% block meta %}
<meta name="description" content="Comprehensive Documentation and
information about HTML.">
<meta name="keywords" content="HTML, tags, commands">
{% endblock meta %}
<title>HTML5</title>
<link rel="stylesheet" href="{{ STATIC_PREFIX }}css/main.css"
type="text/css" />
{% block css %}
{% endblock css %}
</head>

Conclus�o:

Opa, mas n�o tem MEDIA_URL e STATIC_URL no template ???

Sim, a id�ia n�o � s� criar uma varredura dos est�ticos, mas sim
organizar seus links.
� l�gico que utilizar o MEDIA_URL e o STATIC_URL tamb�m funcionam, mas
acredito que seja
apenas para facilitar a migra��o.

Se vc utilizar o get_static_prefix vai notar que tanto faz os arquivos
estarem dentro da sua pasta media ou da static, eles v�o funcionar em
seus templates. Isso � �til para abrir os uploads dos usu�rios na pasta
media. Se o seu diret�rio static estiver dentro de um app, � necess�rio
utilizar o collectstatic.

O comando collectstatic � para manter todos os arquivos est�ticos em
apenas um diret�rio para facilitar a configura��o de um servidor web
(Nginx, Cherokee, Lighthttpd ...) e capturar os arquivos est�ticos dos apps.

Abra�o :D

On 05/18/2011 05:03 PM, Lucas Rezende wrote:
> Agora para eu mesmo me corrigir, me corriJam � com J! HEHE

>
> On May 18, 5:00 pm, Lucas Rezende<lucasgr...@gmail.com> wrote:

>> S� para complementar, pelo que eu li na documenta��o, se voc�

>> especificar o STATIC_URL='/static/' (por exemplo), ele pega o que
>> estiver na pasta "static" do projeto e varre as pastas das apps a

>> procura desse diret�rio. Quando ele encontra, ele move os arquivo que
>> est�o dentro para o diret�rio especificado no STATIC_ROOT para tornar
>> mais f�cil a execu��o.

>>
>> Caso esteja errado, de novo, por favor me corrigam! hehehe
>>

>> Abra�o!

>>
>> On May 18, 4:44 pm, Lucas Rezende<lucasgr...@gmail.com> wrote:
>>
>>
>>
>>
>>
>>
>>

>>> Pelo que eu entendi, o MEDIA_ROOT � o diret�rio que armazanar� os arquivos
>>> de usu�rios (ex.: upload de foto). O MEDIA_URL � o caminho para o
>>> MEDIA_ROOT.
>>> Ex.:
>>> MEDIA_URL='/media/'
>>> Se digitar *www.site.com.br/media/*voc�vai apontar para o que estiver em
>>> *MEDIA_ROOT*, o que torna os arquivos de upload p�blicos.
>>> Por favor, me corrigam se eu estiver errado pois n�o estou certo e gostaria
>>> de entender 100% tamb�m.
>>> Quanto ao STATIC_ROOT, se eu entendi, � um diret�rio utilizado pelo Django

>>> onde ele move temporariamente o que estiver em STATIC_URL para que possa
>>> realizar o processamento.

>>> Novamente, por favor me corrigam se eu estiver errado pois n�o estou certo e
>>> gostaria de entender 100% tamb�m.