---
title: "Como usar o Django com Apache e mod_wsgi"
version: 5.1
locale: pt-br
source: https://docs.djangoproject.com/pt-br/5.1/howto/deployment/wsgi/modwsgi/
canonical: https://djangodocs.dev/pt-br/5.1/howto/deployment/wsgi/modwsgi/
---
# Como usar o Django com Apache e `mod_wsgi`

Implementar Django com [Apache](https://httpd.apache.org/) e [mod\_wsgi](https://modwsgi.readthedocs.io/en/develop/) é uma forma testada e experimentada de colocar o Django em produção.

O mod\_wsgi é um módulo Apache o quam pode hospedar qualquer aplicação Python [WSGI](https://wsgi.readthedocs.io/en/latest/), incluindo Django. Django irá funcionar com qualquer versão do Apache que suporte mod\_wsgi.

A [official mod\_wsgi documentation](https://modwsgi.readthedocs.io/) é sua fonte para todos os detalhes sobre como usar mod\_wsgi. Você provavelmente quer começar com [installation and configuration documentation](https://modwsgi.readthedocs.io/en/develop/installation.html).

## Configuração Básica

Once you’ve got mod\_wsgi installed and activated, edit your Apache server’s
[httpd.conf](https://cwiki.apache.org/confluence/display/httpd/DistrosDefaultLayout) file and add the following.

```apache
WSGIScriptAlias / /path/to/mysite.com/mysite/wsgi.py
WSGIPythonHome /path/to/venv
WSGIPythonPath /path/to/mysite.com

<Directory /path/to/mysite.com/mysite>
<Files wsgi.py>
Require all granted
</Files>
</Directory>
```

A primeira parte da linha `WSGIScriptAlias` é a URL base que você quer servir sua aplicação (`/` indica a URL raiz),  e a segunda é o local do arquivo “WSGI” – veja abaixo – no seu sistema, geralmente dentro do pacote do seu projeto (`mysite` neste exemplo). Isso diz ao Apache para servir qualquer requisição abaixo da URL informada usando a aplicação WSGI definida naquele arquivo.

If you install your project’s Python dependencies inside a [`virtual
environment`](https://docs.python.org/3/library/venv.html#module-venv), add the path using `WSGIPythonHome`. See the [mod\_wsgi
virtual environment guide](https://modwsgi.readthedocs.io/en/develop/user-guides/virtual-environments.html) for more details.

A linha `WSGIPythonPath` assegura que o pacote do seu projeto está disponível no Python path para ser importado; em outras palavras, que `import mysite` funcione.

The `<Directory>` piece ensures that Apache can access your `wsgi.py`
file.

Agora precisamos assegurar que este arquivo `wsgi.py` com objeto de aplicação WSGI exista. Desde de o Django versão 1.4, [`startproject`](/pt-br/5.1/ref/django-admin/#django-admin-startproject) terá criado um para você; se não, você precisará criá-lo. Veja [Documentação geral WSGI](/pt-br/5.1/howto/deployment/wsgi/) para o conteúdo padrão que você deveria colocar neste arquivo, e o que mais você pode adicionar a ele.

> **Warning**
>
> Se múltiplos sites Django estiverem rodando em um único processo mod\_wsgi, todos eles irão usar as definições daquele que executar primeiro. Isso pode ser resolvido alterando:
>
> ```
> os.environ.setdefault("DJANGO_SETTINGS_MODULE", "{{ project_name }}.settings")
> ```
>
> em `wsgi.py`, para:
>
> ```
> os.environ["DJANGO_SETTINGS_MODULE"] = "{{ project_name }}.settings"
> ```
>
> ou por [usando o mode daemon do mod\_wsgi](#daemon-mode) e assegurando que cada site está rodando no seu próprio processo deamon.

> **Arrumando o UnicodeEncodeError para uploads de arquivos**
>
> If you get a `UnicodeEncodeError` when uploading or writing files with
> file names or content that contains non-ASCII characters, make sure Apache
> is configured to support UTF-8 encoding:
>
> ```shell
> export LANG='en_US.UTF-8'
> export LC_ALL='en_US.UTF-8'
> ```
>
> Um lugar comum para colocar essa configuração é em `/etc/apache2/envvars`.
>
> Alternatively, if you are [using mod\_wsgi daemon mode](#daemon-mode)
> you can add `lang` and `locale` options to the `WSGIDaemonProcess`
> directive:
>
> ```text
> WSGIDaemonProcess example.com lang='en_US.UTF-8' locale='en_US.UTF-8'
> ```
>
> Veja a seção [Files](/pt-br/5.1/ref/unicode/#unicode-files) do guia de referência de unicode para detalhes.

## Usando `mod_wsgi` no modo deamon

“Modo Deamon” é o modo recomendado para rodar mod\_wsgi (em plataforma não Windows). Para criar o grupo de processos deamon requerido e delegar o Django para rodar dentro, precisa adicionar as diretivas `WSGIDaemonProcess` e `WSGIProcessGroup`. Um outra mudança requerida na configuração acima se usar deamon mode é que não se pode usar o `WSGIPythonPath`; no lugar deve usar a opção `python-path` para `WSGIDaemonProcess`, por exemplo:

```apache
WSGIDaemonProcess example.com python-home=/path/to/venv python-path=/path/to/mysite.com
WSGIProcessGroup example.com
```

Se quer servir seu projeto em um subdiretório (`https://example.com/mysite` neste exemplo), você pode adicionar `WSGIScriptAlias` a configuração acima:

```apache
WSGIScriptAlias /mysite /path/to/mysite.com/mysite/wsgi.py process-group=example.com
```

Veja a documentação oficial do mod\_wsgi para  [details on setting up daemon mode](https://modwsgi.readthedocs.io/en/develop/user-guides/quick-configuration-guide.html#delegation-to-daemon-process)

## Servindo arquivos

Django doesn’t serve files itself; it leaves that job to whichever web
server you choose.

We recommend using a separate web server – i.e., one that’s not also running
Django – for serving media. Here are some good choices:

- [Nginx](https://nginx.org/en/)
- Uma versão mais enxuta do [Apache](https://httpd.apache.org/)

Se, porém, você não tem opção de servir arquivos de media na mesmo VirtualHost Apache que está o Django, você pode configurar o Apache para servir algumas URLs como media estática, e outros usando a interface mod\_wsgi para  Django.

Este exemplo define o DJango como raiz do site, mas serve `robots.txt`, `favicon.ico`, e qualquer coisa nas URLs `/static/`  e `/media` como arquivos estáticos. Todas as outra URLs serão servidas usando o mod\_wsgi:

```apache
Alias /robots.txt /path/to/mysite.com/static/robots.txt
Alias /favicon.ico /path/to/mysite.com/static/favicon.ico

Alias /media/ /path/to/mysite.com/media/
Alias /static/ /path/to/mysite.com/static/

<Directory /path/to/mysite.com/static>
Require all granted
</Directory>

<Directory /path/to/mysite.com/media>
Require all granted
</Directory>

WSGIScriptAlias / /path/to/mysite.com/mysite/wsgi.py

<Directory /path/to/mysite.com/mysite>
<Files wsgi.py>
Require all granted
</Files>
</Directory>
```

## Persistindo arquivos do admin

When [`django.contrib.staticfiles`](/pt-br/5.1/ref/contrib/staticfiles/#module-django.contrib.staticfiles) is in [`INSTALLED_APPS`](/pt-br/5.1/ref/settings/#std-setting-INSTALLED_APPS), the
Django development server automatically serves the static files of the
admin app (and any other installed apps). This is however not the case when you
use any other server arrangement. You’re responsible for setting up Apache, or
whichever web server you’re using, to serve the admin files.

The admin files live in ([django/contrib/admin/static/admin](https://github.com/django/django/blob/stable/5.1.x/django/contrib/admin/static/admin)) of the
Django distribution.

We **strongly** recommend using [`django.contrib.staticfiles`](/pt-br/5.1/ref/contrib/staticfiles/#module-django.contrib.staticfiles) to handle the
admin files (along with a web server as outlined in the previous section; this
means using the [`collectstatic`](/pt-br/5.1/ref/contrib/staticfiles/#django-admin-collectstatic) management command to collect the
static files in [`STATIC_ROOT`](/pt-br/5.1/ref/settings/#std-setting-STATIC_ROOT), and then configuring your web server to
serve [`STATIC_ROOT`](/pt-br/5.1/ref/settings/#std-setting-STATIC_ROOT) at [`STATIC_URL`](/pt-br/5.1/ref/settings/#std-setting-STATIC_URL)), but here are three
other approaches:

1. Crie um link simbólico para os arquivos estáticos do admin de dentro do seu “document root”(isso talvez requeira +FollowSymLinks\`\`na sua configuração do Apache).
2. Use uma diretiva `Alias`, como demonstrado acima, para apelidar a URL apropriada (provavelmente : settings:SATTIC\_URL\`+ \`\`admin/\`) para o local real dos arquivos do admin.
3. Copie os arquivos estáticos do admin para que entã eles fiquem dentro do “document root” do Apache.

## Autenticação do banco de dados de usuário do Django vindo do Apache.

O Django disponibiliza um facilitador para habilitar o Apache a autenticar usuários diretamente no backend de autenticação do Django. veja   [documentação de autenticação do mod\_wsgi](/pt-br/5.1/howto/deployment/wsgi/apache-auth/).