Como Instalar Django com Postgres, Nginx e Gunicorn no Rocky Linux 9

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

Neste tutorial, você aprenderá como instalar o framework Django em um servidor Rocky Linux 9. Você também criará um projeto de demonstração e o testará.

Pré-requisitos

• Um servidor rodando Rocky Linux 9.
• Um usuário não-root com privilégios sudo.
• Um nome de domínio totalmente qualificado (FQDN) apontando para seu servidor. Para nossos propósitos, usaremos django.example.com como o nome de domínio.
• Certifique-se de que tudo está atualizado.

  $ sudo dnf update

• Instale pacotes utilitários básicos. Alguns deles podem já estar instalados.

  $ sudo dnf install wget curl nano unzip yum-utils -y

• O SELinux está desativado.

Passo 1 - Configurar o Firewall

O primeiro passo é configurar o firewall. O Rocky Linux usa o Firewalld Firewall. Verifique o status do firewall.

$ sudo firewall-cmd --state
running

O firewall funciona com diferentes zonas, e a zona pública é a padrão que usaremos. Liste todos os serviços e portas ativos no firewall.

$ sudo firewall-cmd --permanent --list-services

Deve mostrar a seguinte saída.

cockpit dhcpv6-client ssh

O Django precisa das portas HTTP e HTTPS para funcionar. Abra-as.

$ sudo firewall-cmd --add-service=http --permanent
$ sudo firewall-cmd --add-service=https --permanent

Recarregue o firewall para aplicar as alterações.

$ sudo firewall-cmd --reload

Passo 2 - Instalar PostgreSQL e Utilitários

O Rocky Linux 9 vem com uma versão mais antiga do PostgreSQL. Vamos instalar o Postgres 14 para nosso tutorial.

Instale o RPM do repositório para o PostgreSQL.

$ sudo dnf install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-9-x86_64/pgdg-redhat-repo-latest.noarch.rpm

Instale o servidor PostgreSQL 14.

$ sudo dnf install -y postgresql14-server postgresql14-contrib postgresql14-devel python3-psycopg2

Inicialize o banco de dados.

$ sudo /usr/pgsql-14/bin/postgresql-14-setup initdb

Ative e inicie o serviço PostgreSQL.

$ sudo systemctl enable postgresql-14 --now

Verifique o status do serviço.

$ sudo systemctl status postgresql-14
? postgresql-14.service - PostgreSQL 14 database server
     Loaded: loaded (/usr/lib/systemd/system/postgresql-14.service; enabled; vendor preset: disabled)
     Active: active (running) since Mon 2022-09-12 01:17:24 UTC; 2s ago
       Docs: https://www.postgresql.org/docs/14/static/
    Process: 87995 ExecStartPre=/usr/pgsql-14/bin/postgresql-14-check-db-dir ${PGDATA} (code=exited, status=0/SUCCESS)
   Main PID: 88000 (postmaster)
      Tasks: 8 (limit: 5915)
     Memory: 16.5M
        CPU: 60ms
     CGroup: /system.slice/postgresql-14.service
             ??88000 /usr/pgsql-14/bin/postmaster -D /var/lib/pgsql/14/data/
             ??88001 "postgres: logger "
             ??88003 "postgres: checkpointer "
             ??88004 "postgres: background writer "
             ??88005 "postgres: walwriter "
             ??88006 "postgres: autovacuum launcher "
             ??88007 "postgres: stats collector "
             ??88008 "postgres: logical replication launcher "

Sep 12 01:17:24 board.example.com systemd[1]: Starting PostgreSQL 14 database server...

Vamos instalar alguns utilitários adicionais que precisaremos para o Django funcionar.

$ sudo dnf install -y python3 python3-devel python3-pip gcc

Para resolver quaisquer erros futuros relacionados ao pg_config não encontrado, você precisa adicionar o caminho para a pasta bin do PostgreSQL. Abra o arquivo .bashrc para edição.

$ nano ~/.bashrc

Adicione a seguinte linha no final do arquivo.

export PATH=$PATH:/usr/pgsql-14/bin 

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

Passo 3 - Configurar PostgreSQL

Faça login no shell do PostgreSQL.

$ sudo -i -u postgres psql

Crie um novo banco de dados para o Django.

postgres=# CREATE DATABASE djangoapp;

Crie um novo usuário de banco de dados com uma senha forte.

postgres=# CREATE USER djangouser WITH ENCRYPTED PASSWORD 'dbpassword';

Conceda os direitos ao usuário para usar o banco de dados.

postgres=# GRANT ALL PRIVILEGES ON DATABASE djangoapp TO djangouser;

Saia do Shell do Postgres.

postgres=# \q

Passo 4 - 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 de suas necessidades. Cada método tem seu próprio conjunto de prós e contras. Vamos passar por todos esses métodos.

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.

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 quaisquer pacotes no projeto, você precisa 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.1.2

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 Rocky Linux.

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 instala-o em um modo editável, o 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.dev20221012095013

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.

Passo 5 - 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 pacote Wheel.

(sample_proj) $ pip install wheel

Instale o Django e os pacotes necessários.

(sample_proj) $ pip install django psycopg2 psycopg2-binary

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 .

O Django usa a variável SECRET_KEY para fornecer assinatura criptográfica. Ele gera um valor padrão durante a instalação. Você deve substituí-lo por um valor seguro. Execute o seguinte comando para gerar a chave e copie-a para uso posterior.

(sample_proj) $ python3 -c 'from django.core.management.utils import get_random_secret_key; print(get_random_secret_key())'

Você receberá a seguinte saída com uma chave.

wm#dzb^ymuo3s3tza=f5cx^kan!$4sch1!b-q=v%)=d0pb(jqf

O primeiro passo é ajustar as configurações do projeto. Abra o arquivo de configurações para edição.

(sample_proj) $ nano demoproject/settings.py

Substitua o valor atual da variável SECRET_KEY pela chave que você gerou.

SECRET_KEY = 's)3m=4s&!a=p#brttcqu@1s$8(z6e+u8(^tkpw28qyj0t#8ku2'

Altere as configurações para a seção DATABASES da seguinte forma.

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'DATABASE_DB',
        'USER': 'DATABASE_USER',
        'PASSWORD': 'DATABASE_PASSWORD',
        'HOST': 'DATABASE_HOST',
        'PORT': 'DATABASE_PORT',
    },
}

Em seguida, vá para o final do arquivo e adicione uma configuração para a localização dos arquivos estáticos. Isso é importante para o Nginx funcionar e lidar com solicitações para esses arquivos. Adicione a seguinte linha acima da variável STATIC_URL.

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

Como a variável STATIC_ROOT usa o módulo os, precisamos importá-lo, pois não é importado por padrão. Adicione a seguinte linha acima da linha from pathlib import Path.

import os

Salve o arquivo pressionando Ctrl + X e digitando Y quando solicitado. Verifique as configurações do banco de dados.

(sample_proj) $ python manage.py check --database default

Você deve obter a seguinte saída.

System check identified no issues (0 silenced).

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.

(sample_proj) $ python manage.py makemigrations
(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.

Copie os arquivos estáticos para o diretório estático. Digite yes quando solicitado.

(sample_proj) $ python manage.py collectstatic
130 static files copied to '/home/navjot/dj-sample/static'.

Passo 6 - 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 estar 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 firewall-cmd --add-port=8000/tcp --permanent
(sample_proj) $ sudo firewall-cmd --reload

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ê tenha terminado com seu projeto de demonstração, pode fechar o servidor pressionando Ctrl + C em seu terminal.

Passo 7 - 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 forma que não para mesmo quando um usuário sai.

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á em execução 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á em execução. 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    153474  1.6  3.9  46264 39016 pts/0    S    04:15   0:00 python manage.py runserver 0.0.0.0:8000
navjot    153475  3.0  4.4 196060 43500 pts/0    Sl   04:15   0:00 /home/navjot/dj-sample/sample_proj/bin/python manage.py runserver 0.0.0.0:8000
navjot    153483  0.0  0.2   6420  2248 pts/0    S+   04:15   0:00 grep --color=auto manage.py

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

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

(sample_proj) $ sudo kill -9 153474 153475

Instalar Gunicorn

O segundo método para executar um servidor Django persistente requer que você instale o Gunicorn e os servidores web 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 a segurança e o desempenho que vêm 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:application

Isso iniciará o Gunicorn na mesma interface em que o Django estava sendo executado. 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

Passo 8 - Criar um Socket e Arquivo de 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 systemd 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 \
          -t 3000 \
          --access-logfile - \
          --workers 3 \
          --bind unix:/run/gunicorn.sock \
          demoproject.wsgi:application -w 2

[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; enabled; vendor preset: disabled)
     Active: active (listening) since Thu 2022-10-13 04:19:28 UTC; 14s ago
      Until: Thu 2022-10-13 04:19:28 UTC; 14s ago
   Triggers: ? gunicorn.service
     Listen: /run/gunicorn.sock (Stream)
     CGroup: /system.slice/gunicorn.socket

Oct 13 04:19:28 django.nspeaks.xyz 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 ele está em execução agora.

$ sudo systemctl status gunicorn.service
? gunicorn.service - django gunicorn daemon
     Loaded: loaded (/etc/systemd/system/gunicorn.service; disabled; vendor preset: disabled)
     Active: active (running) since Thu 2022-10-13 06:13:55 UTC; 1min 34s ago
TriggeredBy: ? gunicorn.socket
   Main PID: 157742 (gunicorn)
      Tasks: 4 (limit: 5915)
     Memory: 96.2M
        CPU: 1.198s
     CGroup: /system.slice/gunicorn.service
             ??157742 /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 -w 2
             ??157746 /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 -w 2
             ??157747 /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 -w 2
             ??157748 /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 -w 2
.......

Passo 9 - Instalar Nginx

O último passo é instalar e configurar o Nginx. O Rocky Linux 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.

Crie e abra o arquivo /etc/yum.repos.d/nginx.repo para criar o repositório oficial do Nginx.

$ sudo nano /etc/yum.repos.d/nginx.repo

Cole o seguinte código nele.

[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

[nginx-mainline]
name=nginx mainline repo
baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
gpgcheck=1
enabled=0
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

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

$ sudo dnf install nginx -y

Verifique a instalação.

$ nginx -v
nginx version: nginx/1.22.1

Ative e inicie o servidor Nginx.

$ sudo systemctl enable nginx --now

Verifique o status do servidor.

$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
     Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; vendor preset: disabled)
     Active: active (running) since Thu 2022-10-13 06:17:24 UTC; 1s ago
       Docs: http://nginx.org/en/docs/
    Process: 157900 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
   Main PID: 157901 (nginx)
      Tasks: 2 (limit: 5915)
     Memory: 1.9M
        CPU: 18ms
     CGroup: /system.slice/nginx.service
             ??157901 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
             ??157902 "nginx: worker process"

Oct 13 06:17:24 django.example.com systemd[1]: Starting nginx - high performance web server...

Passo 10 - Instalar SSL

Até agora, sua aplicação Django está sendo servida por uma conexão HTTP sem criptografia. É altamente recomendável que você a proteja por meio de um certificado SSL. Para isso, use a ferramenta Certbot usando a ferramenta Snapd. Ela requer o repositório EPEL para funcionar.

$ sudo dnf install epel-release

Usaremos o Snapd para instalar o Certbot. Instale o Snapd.

$ sudo dnf install snapd

Ative e inicie o serviço Snap.

$ sudo systemctl enable snapd.socket --now

Crie links necessários para o Snapd funcionar.

$ sudo ln -s /var/lib/snapd/snap /snap
$ echo 'export PATH=$PATH:/var/lib/snapd/snap/bin' | sudo tee -a /etc/profile.d/snapd.sh

Instale o repositório core do Snapd.

$ sudo snap install core
$ sudo snap refresh 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 certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d django.example.com

O comando acima fará o download de um certificado para o diretório /etc/letsencrypt/live/django.example.com em seu servidor.

Gere um certificado de grupo Diffie-Hellman.

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Para verificar se a renovação do SSL está funcionando bem, faça um teste do processo.

$ sudo certbot renew --dry-run

Se você não ver erros, está tudo certo. Seu certificado será renovado automaticamente.

Passo 11 - 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.

# enforce HTTPS
server {
  listen 80 default_server;
  server_name django.example.com;
  return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name django.example.com;

    access_log  /var/log/nginx/django.access.log;
    error_log   /var/log/nginx/django.error.log;

    http2_push_preload on; # Enable HTTP/2 Server Push

    ssl_certificate /etc/letsencrypt/live/django.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/django.example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/django.example.com/chain.pem;
    ssl_session_timeout 1d;

    # Enable TLS versions (TLSv1.3 is required upcoming HTTP/3 QUIC).
    ssl_protocols TLSv1.2 TLSv1.3;

    # Enable TLSv1.3's 0-RTT. Use $ssl_early_data when reverse proxying to
    # prevent replay attacks.
    #
    # @see: https://nginx.org/en/docs/http/ngx_http_ssl_module.html#ssl_early_data
    ssl_early_data on;

    ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384';
    ssl_prefer_server_ciphers on;
    ssl_session_cache shared:SSL:50m;

    # OCSP Stapling ---
    # fetch OCSP records from URL in ssl_certificate and cache them
    ssl_stapling on;
    ssl_stapling_verify on;
    ssl_dhparam /etc/ssl/certs/dhparam.pem;

    add_header X-Early-Data $tls1_3_early_data;

    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;
    }
}

# This block is useful for debugging TLS v1.3. Please feel free to remove this
# and use the `$ssl_early_data` variable exposed by NGINX directly should you
# wish to do so.
map $ssl_early_data $tls1_3_early_data {
  "~." $ssl_early_data;
  default "";
}

Substitua a localização 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 à sua 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

Recarregue o servidor Nginx.

$ sudo systemctl reload nginx

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

$ sudo firewall-cmd --remove-port=8000/tcp --permanent
$ sudo firewall-cmd --reload

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

Conclusão

Isso conclui nosso tutorial onde você aprendeu como instalar o Django junto com Gunicorn e Nginx em um servidor Rocky Linux 9. 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.