---
title: "How to manage static files (e.g. images, JavaScript, CSS)"
version: 6.0
locale: pt-br
source: https://docs.djangoproject.com/pt-br/6.0/howto/static-files/
canonical: https://djangodocs.dev/pt-br/6.0/howto/static-files/
---
# How to manage static files (e.g. images, JavaScript, CSS)

Websites generally need to serve additional files such as images, JavaScript,
or CSS. In Django, we refer to these files as “static files”. Django provides
[`django.contrib.staticfiles`](/pt-br/6.0/ref/contrib/staticfiles/#module-django.contrib.staticfiles) to help you manage them.

Está página descreve como você pode servir estes arquivos estáticos.

## Configurando arquivos estáticos

1. Certifique-se de que `django.contrib.staticfiles` está incluído no seu [`INSTALLED_APPS`](/pt-br/6.0/ref/settings/#std-setting-INSTALLED_APPS).
2. Em seu arquivo de configurações, defina [`STATIC_URL`](/pt-br/6.0/ref/settings/#std-setting-STATIC_URL), por exemplo:

   ```
   STATIC_URL = "static/"
   ```
3. In your templates, use the [`static`](/pt-br/6.0/ref/templates/builtins/#std-templatetag-static) template tag to build the URL for
   the given relative path using the configured `staticfiles`
   [`STORAGES`](/pt-br/6.0/ref/settings/#std-setting-STORAGES) alias.

   ```html+django
   {% load static %}
   <img src="{% static 'my_app/example.jpg' %}" alt="My image">
   ```
4. Armazene seus arquivos estáticos no diretório chamado `static` dentro da sua app. Por exemplo `my_app/static/my_app/example.jpg`.

> **Servindo os arquivos**
>
> Além desses passos de configuração, você também vai precisar servir os arquivos estáticos.
>
> Durante o desenvolvimento, se você usar [`django.contrib.staticfiles`](/pt-br/6.0/ref/contrib/staticfiles/#module-django.contrib.staticfiles), isso será feito automaticamente pelo [`runserver`](/pt-br/6.0/ref/django-admin/#django-admin-runserver) quando [`DEBUG`](/pt-br/6.0/ref/settings/#std-setting-DEBUG) está definido como `True` (veja [`django.contrib.staticfiles.views.serve()`](/pt-br/6.0/ref/contrib/staticfiles/#django.contrib.staticfiles.views.serve)).
>
> Este método é **grosseiramente ineficiente** e provavelmente **inseguro**, então isso é **impróprio para produção**.
>
> Veja [How to deploy static files](/pt-br/6.0/howto/static-files/deployment/) para estratégias apropriadas para servir arquivos estáticos em ambientes de produção.

Seu projeto irá provavelmente ter ativos estáticos que não estão amarrados a uma app em particular. Além de usar um diretório `static/` dentro de sua app, você pode definir uma lista de diretórios ([`STATICFILES_DIRS`](/pt-br/6.0/ref/settings/#std-setting-STATICFILES_DIRS)) no seu arquivo de configurações onde o Django também irá procurar por arquivos estáticos. Por exemplo:

```
STATICFILES_DIRS = [
    BASE_DIR / "static",
    "/var/www/static/",
]
```

Veja a documentação para a definição do [`STATICFILES_FINDERS`](/pt-br/6.0/ref/settings/#std-setting-STATICFILES_FINDERS) para detalhes sobre como o `staticfiles` encontra seus arquivos.

> **Namespacing de arquivos estáticos**
>
> Now we *might* be able to get away with putting our static files directly
> in `my_app/static/` (rather than creating another `my_app`
> subdirectory), but it would actually be a bad idea. Django will use the
> first static file it finds whose name matches, and if you had a static file
> with the same name in a *different* application, Django would be unable to
> distinguish between them. We need to be able to point Django at the right
> one, and the best way to ensure this is by *namespacing* them. That is,
> by putting those static files inside *another* directory named for the
> application itself.
>
> You can namespace static assets in [`STATICFILES_DIRS`](/pt-br/6.0/ref/settings/#std-setting-STATICFILES_DIRS) by
> specifying [prefixes](/pt-br/6.0/ref/settings/#staticfiles-dirs-prefixes).

## Servindo arquivos estáticos durante o desenvolvimento

Se você usa o [`django.contrib.staticfiles`](/pt-br/6.0/ref/contrib/staticfiles/#module-django.contrib.staticfiles) como explicado acima, [`runserver`](/pt-br/6.0/ref/django-admin/#django-admin-runserver) vai fazer isso automaticamente quando  estiver configurado como `True`. Se você não tem `django.contrib.staticfiles` em [`INSTALLED_APPS`](/pt-br/6.0/ref/settings/#std-setting-INSTALLED_APPS), você ainda pode manualmente servir arquivos estáticos usando a view [`django.views.static.serve()`](/pt-br/6.0/ref/views/#django.views.static.serve).

Isso não é apropriado para uso em produção! Para algumas estratégias de deploy, veja [How to deploy static files](/pt-br/6.0/howto/static-files/deployment/).

For example, if your [`STATIC_URL`](/pt-br/6.0/ref/settings/#std-setting-STATIC_URL) is defined as `static/`, you can
do this by adding the following snippet to your `urls.py`:

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

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

> **Note**
>
> This helper function works only in debug mode and only if
> the given prefix is local (e.g. `static/`) and not a URL (e.g.
> `http://static.example.com/`).
>
> Esta função de auxiliar serve somente o diretório atual [`STATIC_ROOT`](/pt-br/6.0/ref/settings/#std-setting-STATIC_ROOT); ela não faz a busca de arquivos estáticos como [`django.contrib.staticfiles`](/pt-br/6.0/ref/contrib/staticfiles/#module-django.contrib.staticfiles).
>
> Finally, static files are served via a wrapper at the WSGI application
> layer. As a consequence, static files requests do not pass through the
> normal [middleware chain](/pt-br/6.0/topics/http/middleware/).

## Servindo arquivos que foram enviados pelo usuário durante o desenvolvimento

Durante o desenvolvimento, você pode entregar arquivos de mídia enviados pelos usuários através do [`MEDIA_ROOT`](/pt-br/6.0/ref/settings/#std-setting-MEDIA_ROOT) usando a view [`django.views.static.serve()`](/pt-br/6.0/ref/views/#django.views.static.serve).

Isso não é apropriado para uso em produção! Para algumas estratégias de deploy, veja [How to deploy static files](/pt-br/6.0/howto/static-files/deployment/).

For example, if your [`MEDIA_URL`](/pt-br/6.0/ref/settings/#std-setting-MEDIA_URL) is defined as `media/`, you can do
this by adding the following snippet to your [`ROOT_URLCONF`](/pt-br/6.0/ref/settings/#std-setting-ROOT_URLCONF):

```
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)
```

> **Note**
>
> This helper function works only in debug mode and only if
> the given prefix is local (e.g. `media/`) and not a URL (e.g.
> `http://media.example.com/`).

## Testando

Ao executar testes que usam requisições HTTP reais ao invés do cliente de teste embutido (isto é, quando se usa a [`LiveServerTestCase`](/pt-br/6.0/topics/testing/tools/#django.test.LiveServerTestCase) do Django) o conteúdo estático precisa ser servido junto com o resto do conteúdo então o ambiente de teste reproduz o real tão fielmente quanto possível, mas `LiveServeTestCase` tem somente funcionalidades de servidor muito básicas de arquivos: Ele não sabe sobre as funcionalidades de procura da aplicação `staticfiles` e assume que o conteúdo estático já tenha sido coletado no [`STATIC_ROOT`](/pt-br/6.0/ref/settings/#std-setting-STATIC_ROOT).

Por causa disso, `staticfiles` vem com sua própria [`django.contrib.staticfiles.testing.StaticLiveServerTestCase`](/pt-br/6.0/ref/contrib/staticfiles/#django.contrib.staticfiles.testing.StaticLiveServerTestCase), uma subclasse daquela que vem embutida que tem a habilidade de servir de maneira transparente todos os ativos durante a execução destes testes de uma maneira similar a que temos em tempo de desenvolvimento com `DEBUG = True`, isto é, sem precisar coletá-los usando o [`collectstatic`](/pt-br/6.0/ref/contrib/staticfiles/#django-admin-collectstatic) antes.

## Deploy

[`django.contrib.staticfiles`](/pt-br/6.0/ref/contrib/staticfiles/#module-django.contrib.staticfiles) fornece um comando de gerenciamento conveniente para juntar arquivos estáticos em um único diretório para você poder servi-los facilmente.

1. Defina a configuração do [`STATIC_ROOT`](/pt-br/6.0/ref/settings/#std-setting-STATIC_ROOT) para o diretório do qual você gostaria de servir estes arquivos, por exemplo:

   ```
   STATIC_ROOT = "/var/www/example.com/static/"
   ```
2. Run the [`collectstatic`](/pt-br/6.0/ref/contrib/staticfiles/#django-admin-collectstatic) management command:

   ```shell
   $ python manage.py collectstatic
   ```

   Isso irá copiar todos os arquivos dos seus diretórios estáticos para dentro do diretório definido em [`STATIC_ROOT`](/pt-br/6.0/ref/settings/#std-setting-STATIC_ROOT).
3. Use um servidor Web de sua escolha para servir os arquivos. O [How to deploy static files](/pt-br/6.0/howto/static-files/deployment/) cobre algumas estratégias de deploy comuns para arquivos estáticos.

## Aprenda mais

Este documento cobriu o básico e alguns padrões comuns de uso. Para detalhes completos sobre todas as configurações, comandos, tags de templates, e outras partes incluidas em [`django.contrib.staticfiles`](/pt-br/6.0/ref/contrib/staticfiles/#module-django.contrib.staticfiles), veja a [referência de arquivos estáticos](/pt-br/6.0/ref/contrib/staticfiles/).