Como Servir Aplicativos do Django com Apache e mod_wsgi no Ubuntu 14.04

Introdução

O Django é uma estrutura web poderosa que pode ajudá-lo a obter seu aplicativo ou site Python fora do chão rapidamente. O Django inclui um servidor de desenvolvimento simplificado para testar seu código localmente, mas para qualquer coisa, mesmo um pouco relacionado à produção, um servidor web mais seguro e poderoso é necessário.

Neste guia, vamos demonstrar como instalar e configurar o Django em um ambiente virtual Python. Em seguida, configuraremos o Apache na frente do nosso aplicativo para que ele possa lidar com pedidos de clientes diretamente antes de passar pedidos que exigem lógica de aplicativo para o aplicativo Django. Vamos fazer isso usando o módulo mod_wsgiApache que pode se comunicar com o Django sobre a interface WSGIcification.

Pré-requisitos e metas

Para completar este guia, você deve ter uma nova instância do servidor Ubuntu 14.04 com um usuário não-root com privilégios sudo configurados. Você pode aprender a configurar isso executando o nosso guia inicial de configuração do servidor.

Vamos instalar o Django dentro de um ambiente virtual Python. A instalação do Django em um ambiente específico para seu projeto permitirá que seus projetos e seus requisitos sejam tratados separadamente.

Uma vez que nossa aplicação esteja funcionando, configuraremos o Apache para a interface com o aplicativo Django. Isso fará isso com o módulo mod_wsgi Apache, que pode traduzir solicitações HTTP para um formato de aplicação previsível definido por uma especificação chamada WSGI. Você pode descobrir mais sobre WSGI lendo a seção vinculada neste guia.

Vamos começar.

Instale Pacotes dos Repositórios do Ubuntu

Para iniciar o processo, baixaremos e instalamos todos os itens que precisamos dos repositórios do Ubuntu. Isso incluirá o servidor web Apache, o módulo mod_wsgi usado para interagir com nosso aplicativo Django e pip, o gerenciador de pacotes Python que pode ser usado para baixar nossas ferramentas relacionadas ao Python.

Para obter tudo o que precisamos, atualize o índice do pacote local do servidor e instale os pacotes apropriados.

Se você estiver usando o Django com o Python 2, os comandos que você precisa são:

sudo apt-get update
sudo apt-get install python-pip apache2 libapache2-mod-wsgi

Se, em vez disso, você estiver usando o Django com o Python 3, você precisará de um módulo Apache alternativo. Os comandos apropriados neste caso são:

sudo apt-get update
sudo apt-get install python3-pip apache2 libapache2-mod-wsgi-py3

Ao operar fora de um ambiente virtual para o restante do tutorial, se você estiver usando o Python 3, substitua pip com pip3. Configure um Python Virtual Environment Agora que temos os componentes dos repositórios Ubuntu, podemos começar a trabalhar no nosso projeto Django. O primeiro passo é criar um ambiente virtual Python para que nosso projeto Django seja separado das ferramentas do sistema e de qualquer outro projeto Python em que possamos estar trabalhando. Precisamos instalar o comando virtualenv para criar esses ambientes. Podemos obter isso usando pip:

sudo pip install virtualenv

Com o virtualenv instalado, podemos começar a formar o nosso projeto. Crie um diretório onde você deseja manter seu projeto e entrar no diretório:

mkdir ~/myproject
cd ~/myproject

Dentro do diretório do projeto, crie um ambiente virtual Python digitando:

virtualenv myprojectenv

Isso criará um diretório chamado myprojectenv dentro do seu diretório myproject. No interior, ele instalará uma versão local do Python e uma versão local do pip. Podemos usar isso para instalar e configurar um ambiente Python isolado para o nosso projeto. Antes de instalar os requisitos Python do nosso projeto, precisamos ativar o ambiente virtual. Você pode fazer isso digitando:

source myprojectenv/bin/activate

Seu prompt deve mudar para indicar que você está operando agora em um ambiente virtual Python. Isso parecerá algo como isto: (myprojectenv) user @ host: ~

pip install django

Crie e Configure um Novo Projeto Django Agora que o Django está instalado em nosso ambiente virtual, podemos criar os arquivos reais do projeto Django. Crie o Projeto Django Uma vez que já temos um diretório de projeto, diremos ao Django para instalar os arquivos aqui. Ele criará um diretório de segundo nível com o código real, o que é normal, e colocará um script de gerenciamento neste diretório. A chave para isso é o ponto no final que informa o Django para criar os arquivos no diretório atual:

django-admin.py startproject myproject .

Ajustar as configurações do projeto A primeira coisa que devemos fazer com nossos arquivos de projeto recém-criados é ajustar as configurações. Abra o arquivo de configurações com o editor de texto:

nano myproject/settings.py

Vamos usar o banco de dados SQLite padrão neste guia por motivos de simplicidade, então não precisamos mudar demais. Nos concentraremos na configuração do diretório de arquivos estáticos, onde o Django colocará arquivos estáticos para que o servidor web possa atendê-los facilmente. Na parte inferior do arquivo, adicionaremos uma linha para configurar este diretório. O Django usa o STATIC_ROOTsetting para determinar o diretório onde esses arquivos devem ser exibidos. Usaremos um pouco de Python para dizer para usar um diretório chamado "estático" no diretório principal do nosso projeto:

STATIC_ROOT = os.path.join(BASE_DIR, "static/")

Salve e feche o arquivo quando terminar. Configuração completa do projeto inicial Agora, podemos migrar o esquema do banco de dados inicial para o nosso banco de dados SQLite usando o script de gerenciamento:

cd ~/myproject
./manage.py makemigrations
./manage.py migrate

Crie um usuário administrativo para o projeto digitando:

./manage.py createsuperuser

Você terá que selecionar um nome de usuário, fornecer um endereço de e-mail e escolher e confirmar uma senha.

Podemos coletar todo o conteúdo estático na localização do diretório que configuramos digitando:

./manage.py collectstatic

Você terá que confirmar a operação. Os arquivos estáticos serão colocados em um diretório chamado estático no diretório do projeto.

Finalmente, você pode testar seu projeto iniciando o servidor de desenvolvimento do Django com este comando:./manage.py runserver 0.0.0.0:8000

No seu navegador da Web, visite o nome de domínio ou o endereço IP do servidor seguido de: 8000:

http://server_domain_or_IP:8000

No seu navegador da Web, visite o nome de domínio ou o endereço IP do servidor seguido de: 8000:

Se você adicionar / admin ao final do URL na barra de endereços, você será solicitado para o nome de usuário administrativo e a senha que você criou com o comando createuperuser:

Depois de autenticar, você pode acessar a interface de administração padrão do Django:

Quando terminar de explorar, pressione CTRL-C na janela do terminal para desligar o servidor de desenvolvimento.

Agora estamos com o Django por enquanto, para que possamos voltar ao nosso ambiente virtual digitando:deactivate

Configure o Apache Agora que o seu projeto Django está funcionando, podemos configurar o Apache como um front-end. As conexões de clientes que recebe serão traduzidas para o formato WSGI que o aplicativo Django espera usar o módulo mod_wsgi. Isso deveria ter sido ativado automaticamente após a instalação anterior. Para configurar o passe WSGI, precisamos editar o arquivo de host virtual padrão:

sudo nano /etc/apache2/sites-available/000-default.conf

Podemos manter as diretrizes que já estão presentes no arquivo. Nós só precisamos adicionar alguns itens adicionais.

Para começar, vamos configurar os arquivos estáticos. Usaremos um alias para dizer ao Apache que mapeie quaisquer pedidos que comecem com / estático para o diretório "estático" dentro da nossa pasta de projeto. Nós reunimos os ativos estáticos lá anteriormente. Vamos configurar o alias e, em seguida, conceder acesso ao diretório em questão com um bloco de diretório:

<VirtualHost *:80>
    . . .

    Alias /static /home/user/myproject/static
    <Directory /home/user/myproject/static>
        Require all granted
    </Directory>

</VirtualHost>

Em seguida, iremos conceder acesso ao arquivo wsgi.py no diretório do projeto de segundo nível onde o código Django é armazenado. Para fazer isso, usaremos uma seção de diretório com uma seção de arquivo dentro. Nós concederemos acesso ao arquivo dentro desta construção aninhada:

<VirtualHost *:80>
    . . .

    Alias /static /home/user/myproject/static
    <Directory /home/user/myproject/static>
        Require all granted
    </Directory>

    <Directory /home/user/myproject/myproject>
        <Files wsgi.py>
            Require all granted
        </Files>
    </Directory>

</VirtualHost>

Depois que isso estiver configurado, estamos prontos para construir a parte do arquivo que efetivamente lida com o passe WSGI. Usaremos o modo daemon para executar o processo WSGI, que é a configuração recomendada. Podemos usar a diretiva WSGIDaemonProcess para configurar isso.

Esta diretiva possui um nome arbitrário para o processo. Usaremos meu projeto para permanecer consistente. Posteriormente, configuramos o caminho Python para o diretório pai do projeto. Este será / home / user / myproject neste guia. Uma vez que usamos um ambiente virtual, também precisamos configurar o Python para casa na raiz do nosso ambiente virtual. Desta forma, o Apache pode encontrar todos os outros códigos Python necessários para executar nosso projeto.

Depois, precisamos especificar o grupo de processos. Isso deve apontar para o mesmo nome que selecionamos para a diretiva WSGIDaemonProcess (meu projeto em nosso caso). Finalmente, precisamos definir o alias do script para que o Apache passe pedidos para o domínio raiz para o arquivo wsgi.py:

<VirtualHost *:80>
    . . .

    Alias /static /home/user/myproject/static
    <Directory /home/user/myproject/static>
        Require all granted
    </Directory>

    <Directory /home/user/myproject/myproject>
        <Files wsgi.py>
            Require all granted
        </Files>
    </Directory>

    WSGIDaemonProcess myproject python-path=/home/user/myproject python-home=/home/user/myproject/myprojectenv
    WSGIProcessGroup myproject
    WSGIScriptAlias / /home/user/myproject/myproject/wsgi.py

</VirtualHost>

Quando terminar de fazer essas alterações, guarde e feche o arquivo.

Envolvendo alguns problemas de permissões
Se você estiver usando o banco de dados SQLite, que é o padrão usado neste artigo, você deve permitir o acesso do processo Apache a este arquivo.

Para fazer isso, o primeiro passo é mudar as permissões para que o proprietário do grupo do banco de dados possa ler e escrever. O arquivo de banco de dados é chamado db.sqlite3 por padrão e deve estar localizado no diretório do projeto base:

chmod 664 ~/myproject/db.sqlite3

Depois, precisamos dar ao grupo Apache executado abaixo, o grupo www-data, propriedade do grupo do arquivo:

sudo chown :www-data ~/myproject/db.sqlite3

Para escrever no arquivo, também precisamos dar a propriedade do grupo Apache sobre o diretório pai do banco de dados:

sudo chown :www-data ~/myproject

Uma vez que essas etapas estão concluídas, você está pronto para reiniciar o serviço Apache para implementar as alterações que você fez. Reinicie o Apache digitando:

sudo service apache2 restart