Fala pessoal, hoje estou aqui para apresentar uma solução que utilizei esses dias para rodar uma aplicação Django em produção.

Não sou muito experiente no mundo Python, mas sei que o pessoal costuma a usar bastante servidores wsgi para rodar aplicações da linguagem.

Estava acostumado a subir aplicações Django usando FastCGI em servidores compartilhados (por falta de outra opção), mas em meu último serviço pude subir o projeto em meu vps, então optei por algo mais simples que funcionasse bem.

A opção de usar o Nginx com o Gunicorn me pareceu a melhor, dado o fato que já tinha o servidor web instalado e a integração seria bem fácil.

Preparando Ambiente

Assim como a documentação do Gunicorn recomenda, vamos criar um ambiente isolado com virtualenv para que possamos trabalhar com múltiplas versões do Django.

Instale o virtualenv via pip:

$ sudo pip install virtualenv

Eu particularmente gosto de usar o virtualenvwrapper também, pois facilita um pouco mais, instale ele via pip:

$ sudo pip install virtualenvwrapper

Agora carregue o arquivo do virtualenvwrapper com funções para administrar os ambientes:

$ source /usr/local/bin/virtualenvwrapper.sh

Adicione essa mesma linha acima no final do arquivo ~/.bashrc ou ~/.bash_profile para que os comandos sejam carregados junto com o shell.

Vamos criar um ambiente agora:

$ mkvirtualenv django-1.5

Aqui estou criando um ambiente chamado "django-1.5", usaremos ele para trabalhar com projetos dessa versão do Django.

Se você rodar $ ls ~/.virtualenvs verá que um diretório "django-1.5" foi criado, nessa pasta serão armazenadas as bibliotecas do nosso ambiente.

Observe também que no shell teremos o nome do ambiente entre parênteses antes do nome do usuário, desse jeito: (django-1.5)glauco@glauco-note ~$. Isso significa que esse ambiente está ativo, para desativá-lo rode $ deactivate django-1.5 e para ativar, basta rodar $ workon django-1.5.

Nosso ambiente isolado está criado no servidor, agora precisamos fazer deploy do projeto e instalar as dependências (como o Django, South etc..).

Saindo do servidor e indo para nosso ambiente local de desenvolvimento, vamos congelar as dependências do projeto em um arquivo txt:

$ pip freeze > requirements.txt

Faça deploy no servidor de produção usando git ou ferramentas como Fabric, acesse a pasta do arquivo com as dependências do projeto e instale-as via $ pip install -r requirements.txt.

Instalando e Configurando Gunicorn

Instalar o Gunicorn é fácil, basta rodar pip install gunicorn e pronto.

A partir da versão 1.4 do Django, quando criamos um projeto, ele vem com um arquivo chamado wsgi.py que serve para fazer a ligação entre o servidor web (nesse exemplo Nginx) e o servidor de aplicação (nesse exemplo Gunicorn).

Precisamos alterar o arquivo para adicionar o caminho de nossa aplicação ao python path:

# wsgi.py
import os, sys

PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__))
settings_module = "%s.settings" % PROJECT_ROOT.split(os.sep)[-1]
if PROJECT_ROOT not in sys.path:
    sys.path.append(PROJECT_ROOT)
os.environ.setdefault("DJANGO_SETTINGS_MODULE", settings_module)

from django.core.wsgi import get_wsgi_application
application = get_wsgi_application()

Aqui pegamos o caminho absoluto do projeto e verificamos se ele está no python path, senão estiver, adicionamos, depois dizemos ao Django qual a localização do arquivo settings.py.

Vamos rodar nossa aplicação para testar:

$ gunicorn -b "127.0.0.1:8007" meu_projeto.wsgi:application

O código acima deve ser executado no diretório acima do projeto, nesse caso ~/, pois o projeto está em ~/meu_projeto. Troque "meu_projeto" pelo nome do diretório que contém seu projeto.

Se tudo deu certo, você já tem o Gunicorn rodando.

Servindo Arquivos Estáticos com Nginx

Não é recomendado servir arquivos estáticos com o Django, por isso precisamos de um servidor web para fazer o serviço, nesse tutorial iremos usar o Nginx.

Considerando que você já tenha ele instalado, vamos configurar um servidor como abaixo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
server {
  listen   8006;
  passenger_enabled off;
  server_name localhost;
  root /home/superuser/meu_projeto;
  location /static/ {
    alias /home/superuser/meu_projeto/my_template/static/;
    if ($query_string) {
      expires max;
    }
  }
  location / {
    proxy_pass_header Server;
    proxy_set_header Host $http_host;
    proxy_redirect off;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Scheme $scheme;
    proxy_connect_timeout 30;
    proxy_read_timeout 20;
    proxy_pass http://127.0.0.1:8007;
  }
}

Aqui definimos um servidor ouvindo na porta 8006, mapeando as urls que começam com /static/ para o caminho de arquivos estáticos de nossa aplicação e que define um proxy reverso que serve para jogar as requisições ao Gunicorn que está escutando na porta 8007 (como foi definido no teste anteriormente).

Ao terminar de configurar o Nginx, reinicie-o e acesse o servidor via ip mesmo (por ex: http://111.222.33.444:8006) e já devemos ter nossa aplicação rodando.

Automatizando Startup do Gunicorn com Upstart

Poderiamos parar por aqui pois já temos o que precisamos, mas imagine só que você precise reinicar o processo do Gunicorn ao fazer um deploy, da forma que está, você precisaria dar um ps aux para localizar o processo e depois matá-lo, isso não é muito legal.

Servidores Ubuntu possuem o Upstart, com ele conseguimos controlar serviços apenas rodando um sudo stop nome_servico e sudo start nome_servico, além da garantia que ele nos dá que o processo sempre estará rodando, é disso que precisamos.

Vamos criar um arquivo chamado start.sh na pasta do projeto que seja responsável por subir nossa aplicação:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#!/bin/bash
set -e
APP_NAME='meu_projeto'
APP_PATH=/home/superuser
ENV_PATH=$APP_PATH/.virtualenvs/django-1.5
LOGFILE="$APP_PATH/$APP_NAME/log"
NUM_WORKERS=3
# user/group to run as
USER=superuser
#GROUP=your_unix_group
PORT=8007
source $ENV_PATH/bin/activate
cd "$APP_PATH/"
exec gunicorn -w $NUM_WORKERS -b "127.0.0.1:$PORT" --user=$USER --log-level=debug --log-file=$LOGFILE 2>>$LOGFILE "$APP_NAME.wsgi:application"

Dê permissão de execução a ele via $ chmod +x start.sh.

Nesse arquivo defino algumas variáveis para que possamos usar na inicializaçao do servidor. Atente para a linha 12, nela eu ativo o ambiente a ser utilizado, isso é muito importante.

Na linha 7 definimos quantos workers o Gunicorn usará, recomenda-se utilizar a seguinte fórmula para calcular: 1 + 2 * NUMERO DE CORES DO PROCESSADOR.

Com nosso script de inicialização pronto, vamos criar um novo serviço no Upstart para cuidar dele. Acesse a pasta /etc/init e crie um arquivo chamado meu_projeto.conf com o seguinte conteúdo:

description "Meu Projeto Gunicorn"
start on runlevel [2345]
stop on runlevel [016]
respawn

exec su - superuser -c '/home/superuser/meu_projeto/start.sh'

Salve e pronto, agora você pode controlar o Gunicorn via sudo start meu_projeto e sudo stop meu_projeto.

Abraços.