Como Instalar o Framework Django Python no Ubuntu 22.04

Django é um framework Python usado para desenvolver sites e aplicações dinâmicas. Ele segue a arquitetura MVC (Model-View-Controller). Usar o Django acelera o processo de desenvolvimento, pois a maioria das tarefas subjacentes é gerenciada por ele.

Este tutorial ensinará como instalar o framework Django em um servidor Ubuntu 22.04. Você também criará um projeto de demonstração e o testará.

Pré-requisitos

• Um servidor rodando Ubuntu 22.04.
• Um usuário sudo não-root.
• Certifique-se de que tudo está atualizado. $ sudo apt update $ sudo apt upgrade

Instalar Django

Existem vários métodos pelos quais você pode instalar o Django. Decidir qual funciona melhor para você depende de como você deseja configurar seu ambiente de desenvolvimento e suas necessidades. Cada método tem seu próprio conjunto de prós e contras. Vamos passar por todos esses métodos.

Instalar a partir dos Repositórios do Ubuntu

O método mais simples para instalar o Django é usar os repositórios do Ubuntu. O Ubuntu 22.04 vem com Python 3.10. Você pode verificar usando o seguinte comando.

$ python3 -V
Python 3.10.4

Instale o Django usando o seguinte comando.

$ sudo apt install python3-django

Execute o seguinte comando para verificar a instalação bem-sucedida.

$ django-admin --version
3.2.12

A versão do Django fornecida com o Ubuntu é a versão LTS atual, que é suportada até 2024. No entanto, não é a versão mais recente. Se você deseja instalar um lançamento recente, este método não é para você.

Instalar usando pip

Esta é a maneira mais comum de instalar o Django. A maneira recomendada de fazer isso é criando um ambiente virtual Python. Isso permite que você instale pacotes Python sem afetar o sistema.

Instale o módulo pip e venv. venv é usado para criar ambientes virtuais Python e pip instala pacotes Python.

$ sudo apt install python3-pip python3-venv

Vamos criar um diretório de projeto de demonstração.

$ mkdir ~/sampleproject
$ cd ~/sampleproject

Crie um ambiente virtual usando o seguinte comando. Substitua sample_env pelo nome que você deseja dar ao seu ambiente virtual.

$ python3 -m venv sample_env

Isso instala uma versão portátil do Python, pip dentro do seu diretório de projeto. Para instalar qualquer pacote no projeto, você deve ativar o ambiente usando o seguinte comando.

$ source sample_env/bin/activate

Seu prompt de shell mudará para refletir o ambiente virtual.

(sample_env) navjot@django:~/sampleproject$

Agora que o ambiente virtual está ativado, use pip para instalar o Django. Execute o seguinte comando para instalar o Django.

(sample_env) $ pip install django

Verifique a instalação.

(sample_env) $ django-admin --version
4.0.5

Dependendo dos requisitos do seu projeto, você pode instalar uma versão diferente do Django da seguinte maneira.

(sample_env) $ pip install django==3.2.1

Verifique a instalação.

(sample_env) $ django-admin --version
3.2.1

Como você pode ver, este método instala uma versão mais nova do Django do que a versão obtida do repositório do Ubuntu.

Para sair do ambiente virtual, execute o seguinte comando.

(sample_env) $ deactivate

Instalar a versão de desenvolvimento

Você também pode usar pip para instalar a versão de desenvolvimento do Django. Para isso, vamos pegar a versão de desenvolvimento do repositório do Github do Django.

Clone o repositório para o diretório ~/django-dev usando o seguinte comando.

$ git clone https://github.com/django/django ~/django-dev

Mude para o diretório recém-criado.

$ cd ~/django-dev

Crie o ambiente virtual.

$ python3 -m venv dev_django_env

Ative o ambiente.

$ source dev_django_env/bin/activate

Instale o Django usando pip. A flag -e o instala em um modo editável, que é necessário se você estiver instalando a partir do controle de versão.

(dev_django_dev) $ pip install -e ~/django-dev

Verifique a instalação.

(dev_django_dev) $ django-admin --version
4.2.dev20220628195651

Como você pode ver, a versão aqui é a versão de desenvolvimento mais recente. A versão de desenvolvimento do Django não é útil para ambientes de produção.

Criar um Projeto de Amostra

Vamos construir um projeto Django de amostra. Crie um diretório para o projeto de amostra.

$ mkdir ~/dj-sample
$ cd ~/dj-sample

Crie um ambiente virtual Python.

$ python3 -m venv sample_proj

Ative o ambiente.

$ source sample_proj/bin/activate

Instale o Django.

(sample_proj) $ pip install django

Para construir o projeto, precisamos usar o comando startproject. Este comando cria outro diretório que inclui:

• Um script de gerenciamento, manage.py, usado para administrar tarefas específicas do Django.
• Um diretório com o mesmo nome do projeto que inclui o código do projeto.

Vamos criar o diretório do projeto em nosso diretório de trabalho atual. Para fazer isso, use o caractere ponto (.) no final do seguinte comando.

(sample_proj) $ django-admin startproject demoproject .

Em seguida, precisamos migrar o banco de dados usando o comando migrate. As migrações no Django propagam as alterações que você faz em seus modelos para o esquema do banco de dados. O Python usa o banco de dados SQLite por padrão.

(sample_proj) $ python manage.py migrate

Você receberá a seguinte saída.

Operations to perform:
  Apply all migrations: admin, auth, contenttypes, sessions
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying admin.0002_logentry_remove_auto_add... OK
  Applying admin.0003_logentry_add_action_flag_choices... OK
  Applying contenttypes.0002_remove_content_type_name... OK
  Applying auth.0002_alter_permission_name_max_length... OK
  Applying auth.0003_alter_user_email_max_length... OK
  Applying auth.0004_alter_user_username_opts... OK
  Applying auth.0005_alter_user_last_login_null... OK
  Applying auth.0006_require_contenttypes_0002... OK
  Applying auth.0007_alter_validators_add_error_messages... OK
  Applying auth.0008_alter_user_username_max_length... OK
  Applying auth.0009_alter_user_last_name_max_length... OK
  Applying auth.0010_alter_group_name_max_length... OK
  Applying auth.0011_update_proxy_permissions... OK
  Applying auth.0012_alter_user_first_name_max_length... OK
  Applying sessions.0001_initial... OK

Em seguida, crie um usuário administrativo para acessar a interface administrativa do Django.

(sample_proj) $ python manage.py createsuperuser

Você será solicitado a fornecer um nome de usuário, e-mail e senha.

Username (leave blank to use 'navjot'):
Email address: [email protected]
Password:
Password (again):
Superuser created successfully.

Testar o Servidor de Desenvolvimento

É hora de testar a aplicação. Para isso, você precisa modificar a diretiva ALLOWED_HOSTS nas configurações do Django. Esta diretiva define a lista de endereços IP e nomes de domínio que têm acesso à aplicação Django.

Abra o arquivo de configurações usando o seguinte comando.

(sample_proj) $ nano demoproject/settings.py

Encontre a seguinte entrada.

ALLOWED_HOSTS = []

Digite o endereço IP do seu servidor nos colchetes. Cada entrada deve ser colocada entre aspas e várias entradas precisam ser separadas por vírgulas. Digitar www.example.com será correspondido exatamente. No entanto, .example.com corresponderá a example.com e www.example.com, e qualquer outro subdomínio de example.com. Portanto, é recomendável usar o ponto para prefixar um nome de domínio para corresponder a ele e seus subdomínios.

ALLOWED_HOSTS = ['']

Usamos o endereço IP para corresponder ao nosso servidor. Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.

Antes de testar o servidor de desenvolvimento, você precisa configurar o firewall para permitir que o Django funcione. O Django usa a porta 8000 por padrão. Abra a porta usando o Firewall Descomplicado (UFW).

(sample_proj) $ sudo ufw allow 8000

Inicie o servidor de desenvolvimento.

(sample_proj) $ python manage.py runserver 0.0.0.0:8000

Abra a URL http://:8000 em seu navegador e você verá a seguinte tela.

Você pode acessar a interface administrativa seguindo a URL http://:8000/admin/ e verá a seguinte tela de login.

Digite as credenciais criadas anteriormente para fazer login no painel administrativo mostrado abaixo.

Uma vez que você termine seu projeto de demonstração, pode fechar o servidor pressionando Ctrl + C em seu terminal.

Instalar e Testar o Gunicorn

Executar servidor Django persistente usando nohup

Até agora, o serviço do Django não é persistente. Para tornar o serviço persistente, existem dois métodos. O primeiro método envolve usar o utilitário nohup. O nohup é um comando POSIX que significa sem desligar. Ele é usado para executar comandos de uma maneira que não para mesmo quando um usuário faz logout.

Certifique-se de que você saiu do servidor do terminal pressionando Ctrl + C.

Execute o seguinte comando para executar o servidor de desenvolvimento do Django.

(sample_proj) $ nohup python manage.py runserver 0.0.0.0:8000 &

Agora, seu servidor Django continuará rodando até que você o mate manualmente. O comando lhe dará o ID do processo e saídas de outro comando.

[1] 42595
(sample_proj) $ nohup: ignoring input and appending output to 'nohup.out'
^C

Pressione Ctrl + C para sair. O servidor Django original continuará rodando. Você pode verificar abrindo a URL em seu navegador.

Uma vez que você tenha terminado, você precisa matar o processo. O comando nohup lhe dá um ID de processo. Mas na realidade, dois processos estão sendo executados. Para encontrar os IDs de ambos os processos, execute o seguinte comando.

(sample_proj) $ ps aux | grep manage.py
navjot     42650  3.6  1.8  47792 38168 pts/0    S    02:28   0:00 python manage.py runserver 0.0.0.0.:8000
navjot     42651  7.9  2.0 344904 41708 pts/0    Sl   02:28   0:00 /home/navjot/dj-sample/sample_proj/bin/python manage.py runserver 0.0.0.0:8000
navjot     42657  0.0  0.1   6612  2172 pts/0    S+   02:28   0:00 grep --color=auto manage.py

Como você pode ver, dois processos estão sendo executados, um com ID 42650 e o outro com ID 42651.

Execute o seguinte comando para desligar o servidor usando os IDs de processo que você obteve acima.

(sample_proj) $ sudo kill -9 42650 42651

Instalar Gunicorn

O segundo método para executar um servidor Django persistente requer que você instale os servidores web Gunicorn e Nginx. O Gunicorn é um servidor HTTP WSGI Python. Ele irá interagir com a aplicação Django e, em seguida, o Nginx atuará como um proxy reverso para o Gunicorn. Este método tem o benefício adicional de fornecer segurança e desempenho que vem com o uso do Nginx.

Instale o Gunicorn.

(sample_proj) $ pip install gunicorn

Antes de prosseguir, precisamos testar a capacidade do Gunicorn de servir o projeto. Execute o seguinte comando para executar o Gunicorn.

(sample_proj) $ gunicorn --bind 0.0.0.0:8000 demoproject.wsgi

Isso iniciará o Gunicorn na mesma interface em que o Django estava rodando. Para verificar, abra a URL http://:8000 em seu navegador e você verá a mesma página inicial do Django. Isso significa que o Gunicorn está funcionando perfeitamente.

Quando você terminar de testar, pressione Ctrl + C no terminal para sair do Gunicorn.

Desative o ambiente virtual para voltar ao seu shell regular.

(sample_proj) $ deactivate

Criar um arquivo de Socket e Serviço para o Gunicorn

O primeiro passo é criar um arquivo de socket do Gunicorn. O socket do Gunicorn será criado na inicialização e ouvirá por conexões. Quando uma conexão ocorrer, o systems iniciará automaticamente o processo do Gunicorn para lidar com isso.

Crie e abra o arquivo de socket do Gunicorn para edição.

$ sudo nano /etc/systemd/system/gunicorn.socket

Cole o seguinte código nele.

[Unit]
Description=gunicorn socket

[Socket]
ListenStream=/run/gunicorn.sock

[Install]
WantedBy=sockets.target

Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.

Em seguida, crie e abra o arquivo de serviço do Gunicorn para edição.

$ sudo nano /etc/systemd/system/gunicorn.service

Cole o seguinte código nele.

[Unit]
Description=django gunicorn daemon
Requires=gunicorn.socket
After=network.target

[Service]
User=navjot
Group=nginx
WorkingDirectory=/home/navjot/dj-sample
ExecStart=/home/navjot/dj-sample/sample_proj/bin/gunicorn \
          --access-logfile - \
          --workers 3 \
          --bind unix:/run/gunicorn.sock \
          demoproject.wsgi:application

[Install]
WantedBy=multi-user.target

Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado. Substitua navjot pelo seu nome de usuário do sistema. O grupo nginx permitirá que o servidor Nginx se comunique com o Django.

Recarregue o daemon do sistema para atualizar os arquivos do systemd.

$ sudo systemctl daemon-reload

Ative e inicie o arquivo de socket do Gunicorn.

$ sudo systemctl start gunicorn.socket
$ sudo systemctl enable gunicorn.socket

Verifique o status do socket do Gunicorn.

$ sudo systemctl status gunicorn.socket

Você receberá uma saída semelhante.

? gunicorn.socket - gunicorn socket
     Loaded: loaded (/etc/systemd/system/gunicorn.socket; disabled; vendor preset: enabled)
     Active: active (listening) since Thu 2022-06-30 01:43:24 UTC; 20s ago
   Triggers: ? gunicorn.service
     Listen: /run/gunicorn.sock (Stream)
     CGroup: /system.slice/gunicorn.socket

Jun 30 01:43:24 django systemd[1]: Listening on gunicorn socket.

O serviço do Gunicorn ainda não está em execução, como você pode verificar.

$ sudo systemctl status gunicorn.service
? gunicorn.service - django gunicorn daemon
     Loaded: loaded (/etc/systemd/system/gunicorn.service; disabled; vendor preset: enabled)
     Active: inactive (dead)
TriggeredBy: ? gunicorn.socket

Para testar o mecanismo de ativação do socket, execute o seguinte comando.

$ curl --unix-socket /run/gunicorn.sock localhost

Você receberá a saída HTML da página inicial do Django em seu terminal. Isso também inicia o Gunicorn para servir a aplicação. Verifique o status do serviço novamente e você verá que agora está em execução.

$ sudo systemctl status gunicorn.service
? gunicorn.service - django gunicorn daemon
     Loaded: loaded (/etc/systemd/system/gunicorn.service; disabled; vendor preset: enabled)
     Active: active (running) since Thu 2022-06-30 01:45:09 UTC; 12s ago
TriggeredBy: ? gunicorn.socket
   Main PID: 42365 (gunicorn)
      Tasks: 4 (limit: 2241)
     Memory: 91.7M
        CPU: 1.128s
     CGroup: /system.slice/gunicorn.service
             ??42365 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application
             ??42366 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application
             ??42367 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application
             ??42368 /home/navjot/dj-sample/sample_proj/bin/python3 /home/navjot/dj-sample/sample_proj/bin/gunicorn --access-logfile - --workers 3 --bind unix:/run/gunicorn.sock demoproject.wsgi:application

Jun 30 01:45:09 django systemd[1]: Started django gunicorn daemon.
Jun 30 01:45:09 django gunicorn[42365]: [2022-06-30 01:45:09 +0000] [42365] [INFO] Starting gunicorn 20.1.0
Jun 30 01:45:09 django gunicorn[42365]: [2022-06-30 01:45:09 +0000] [42365] [INFO] Listening at: unix:/run/gunicorn.sock (42365)
Jun 30 01:45:09 django gunicorn[42365]: [2022-06-30 01:45:09 +0000] [42365] [INFO] Using worker: sync
Jun 30 01:45:09 django gunicorn[42366]: [2022-06-30 01:45:09 +0000] [42366] [INFO] Booting worker with pid: 42366
.......

Instalar Nginx

O último passo é instalar e configurar o Nginx. O Ubuntu 22.04 vem com uma versão mais antiga do Nginx. Você precisa baixar o repositório oficial do Nginx para instalar a versão mais recente.

Importe a chave de assinatura do Nginx.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Adicione o repositório para a versão estável do Nginx.

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \
http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list

Atualize os repositórios do sistema.

$ sudo apt update

Instale o Nginx.

$ sudo apt install nginx

Verifique a instalação.

$ nginx -v
nginx version: nginx/1.22.0

Configurar Nginx

Crie e abra o arquivo /etc/nginx/conf.d/django-gunicorn.conf para edição.

$ sudo nano /etc/nginx/conf.d/django-gunicorn.conf

Cole o seguinte código nele.

server {
    listen 80;
    server_name server_domain_or_IP;

    location = /favicon.ico { access_log off; log_not_found off; }
    location /static/ {
        root /home/navjot/dj-sample;
    }

    location / {
        proxy_set_header Host $http_host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_pass http://unix:/run/gunicorn.sock;
    }
}

Substitua o local raiz no arquivo acima pelo diretório em seu servidor.

Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.

Abra o arquivo /etc/nginx/nginx.conf para edição.

$ sudo nano /etc/nginx/nginx.conf

Adicione a seguinte linha antes da linha include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.

Verifique sua configuração do Nginx.

$ sudo nginx -t

Se você não ver erros, significa que está tudo certo.

Você também precisará adicionar o nome de domínio à diretiva ALLOWED_HOSTS. Abra o arquivo settings.py.

$ nano ~/dj-sample/demoproject/settings.py

Altere o valor da variável ALLOWED_HOSTS.

ALLOWED_HOSTS = ['','django.example.com']

Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado.

Reinicie o Socket e o Serviço do Gunicorn.

$ sudo systemctl restart gunicorn.socket
$ sudo systemctl restart gunicorn.service

Inicie o servidor Nginx.

$ sudo systemctl start nginx

Abra a porta HTTP. Você também pode excluir a porta 8000 se não for mais usá-la.

$ sudo ufw delete allow 8000
$ sudo ufw allow http

Verifique abrindo a URL http://django.example.com e a página inicial do Django será carregada.

Instalar SSL

Até agora, sua aplicação Django está sendo servida por uma conexão HTTP em texto simples. É altamente recomendável que você a proteja por meio de um certificado SSL. Para isso, use a ferramenta Certbot usando a ferramenta Snapd. Ela já está instalada em um sistema Ubuntu 22.04.

Instale o repositório core do Snapd.

$ sudo snap install core

Instale o Certbot.

$ sudo snap install --classic certbot
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Gere o certificado. O seguinte comando também configurará automaticamente o Nginx.

$ sudo certbot --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d django.example.com

Abra a porta HTTPS primeiro.

$ sudo ufw allow https

Visite a URL https://django.example.com em seu navegador para confirmar.

Conclusão

Isso conclui nosso tutorial, onde você aprendeu como instalar o Django e o Gunicorn e o Nginx em um servidor Ubuntu 22.04. Você também instalou um certificado SSL para aumentar a segurança do seu projeto Django. Se você tiver alguma dúvida, poste nos comentários abaixo.