Tutorial Django: entendendo os fundamentos do framework Django 

O Django é um framework Python de alto nível usado para atividades de desenvolvimento rápido e de design simples e pragmático. Ele simplifica muitas tarefas de desenvolvimento web, permitindo que você se concentre em desenvolver sua aplicação sem precisar reinventar a roda.

Isso faz do Django um dos frameworks mais populares e amplamente utilizados para criar sites e aplicativos dinâmicos e orientados por dados.

Neste tutorial, vamos apresentar os fundamentos básicos do Django e fornecer uma base sólida para que você possa criar sua primeira aplicação web com esse framework. Você vai conhecer todos os processos básicos, desde a configuração de uma VPS e a instalação do Python até o deployment, ou lançamento, do seu projeto Django.

Ao final deste tutorial, você será capaz de desenvolver uma aplicação web totalmente funcional e entender como continuar a desenvolver seus próprios projetos usando o Django. Se você é novo no mundo do desenvolvimento web ou está procurando expandir suas habilidades, este tutorial Django vai te ajudar a dominar o essencial.

Instalando o framework Django 

Antes de começar a criar uma aplicação Django, é necessário configurar um ambiente de desenvolvimento. Esse processo inclui a configuração de uma VPS, a instalação do Python, a criação de um ambiente virtual e a instalação do Django.

Pré-requisitos

Antes de começar a trabalhar com o Django, é importante ter um entendimento básico de determinados conceitos de programação. Listamos algumas noções que você deve dominar:

• Conhecimento básico de Python: Compreensão sólida dos fundamentos do Python –  tipos de dados, fluxo de controle, funções, classes, módulos. 
• Noções iniciais de HTML, CSS e JavaScript: Conhecimento básico de HTML, CSS e JavaScript. 
• Compreensão de bancos de dados: Conceitos relativos a banco de dados  – tabelas, relatórios, chave primária, chave estrangeira. Ter conhecimento em SQL é uma vantagem.
• Familiaridade com a interface de linha de comando (CLI): Conhecimento básico dos comandos essenciais do Linux.

Atendendo a estas condições, você estará bem preparado para entender e executar as etapas necessárias para instalar o Django e começar a criar seus projetos online.

Adquira um VPS django

Escolher o ambiente de hospedagem correto é crucial para desenvolver e executar sua aplicação Django. Um Servidor Virtual Privado (VPS) oferece mais controle, recursos e capacidade de expansão do que uma hospedagem compartilhada, por isso, é ideal para projetos Django. A hospedagem VPS Django da Hostinger é uma excelente opção, com planos acessíveis, os servidores são fáceis de configurar e gerenciar.

Ao selecionar um plano VPS da Hostinger, considere as necessidades de seu projeto:

• CPU e RAM: CPU mais rápida e mais capacidade de RAM proporcionam melhor desempenho, especialmente para aplicativos mais complexos ou volumes de tráfego mais altos.
• Armazenamento: Os aplicativos Django geralmente trabalham com bancos de dados e arquivos estáticos. Sua VPS deve ter armazenamento SSD suficiente para as exigências do seu projeto.
• Banda larga: esse recurso depende do tráfego esperado, assim, escolha um plano com largura de banda suficiente para suportar seus visitantes sem causar lentidão.

Para um projeto Django básico, um plano VPS básico, como KVM 1 ou KVM 2, costuma ser suficiente. Porém, à medida que seu projeto crescer, você poderá facilmente fazer um upgrade para opções de planos com mais recursos.

Depois de escolher uma hospedagem VPS e concluir a compra, siga as etapas a seguir para configurar seu servidor:

1. Iniciar a configuração: Faça login na sua conta e acesse o hPanel. Na página inicial, você verá uma configuração de VPS pendente, semelhante a esta:

2. Pressione Setup e Start Now para começar a configurar seu servidor.
3. Selecione um local de hospedagem: considere a região de onde está esperando receber tráfego. A região de menor latência não é necessariamente a melhor para o seu aplicativo, por exemplo, se o tráfego esperado vier da Austrália enquanto você estiver na Europa.

4. Selecione o sistema operacional: Para seguir o passo-a-passo deste tutorial, você deve selecionar o sistema operacional Ubuntu simples. No entanto, vale lembrar que a Hostinger também oferece opções de sistema operacional com painel e um sistema operacional com application stack (dependências de software pré-instaladas).
5. Configure suas credenciais: Digite a senha root e adicione uma chave SSH, se desejar. Conclua a configuração.
6. Conecte-se via SSH: use um cliente SSH (por exemplo, PuTTY para Windows ou o terminal para macOS/Linux) para se conectar ao servidor. No terminal, digite:

ssh root@ip_do_seu_vps

7. Substitua your_vps_ip pelo endereço IP da VPS da Hostinger. Em seguida, você deverá digitar sua senha.
8. Atualize o servidor: É importante atualizar seu servidor. Execute o seguinte comando para atualizar os pacotes do sistema:

apt update && apt upgrade -y

Com a hospedagem VPS pronta, você já pode instalar o Python e outras dependências necessárias para o desenvolvimento Django.

Instale o Python

Para executar o Django, você precisará instalar o Python e o sistema de pacotes pip na VPS. A maioria dos sistemas operacionais modernos do Linux, como o Ubuntu, já vem com o Python pré-instalado.

Se você não tiver instalado ou precisar atualizar o Python, o processo é bem simples. Use os comandos abaixo para verificar a versão atual e instalar a versão mais recente do Python3:

1. Verifique se o Python está instalado:

python3 --version

2. Se sua interface de linha de comando retornar o número da versão do Python, a linguagem de programação já está instalada. Nesse caso, você só precisa instalar o pip:

apt install python3-pip

3. Instale o Python e o pip (se necessário):

apt install python3 python3-pip -y

Depois que o Python estiver instalado, você estará pronto para configurar um ambiente virtual.

Configure um ambiente virtual

Um ambiente virtual é um espaço isolado no qual você pode instalar pacotes e dependências Python para desenvolver um projeto específico. Esse método não afeta o ambiente Python de todo o sistema ou outros projetos.

Essa etapa é crucial para trabalhar com o Django, já que projetos diferentes podem exigir versões diferentes de certos pacotes. Um ambiente virtual garante que as dependências de cada projeto estejam contidas de forma organizada e não entrem em conflito umas com as outras.

Por que usar um ambiente virtual?

• Isolamento: Mantém as dependências de seu projeto separadas de outros projetos Python.
• Controle de versões: Você pode instalar diferentes versões de pacotes em cada espaço de trabalho virtual, evitando conflitos entre projetos.
• Ambiente mais limpo: Permite que você faça experiências com pacotes sem afetar todo o ambiente Python do seu servidor.

Siga as etapas abaixo para configurar um ambiente virtual Python em sua VPS:

1. Instale o pacote venv (se ele ainda não estiver instalado):

apt install python3-venv -y

2. Crie o diretório onde você deseja armazenar seu projeto Django e crie um ambiente virtual:

mkdir myprojectcd myproject

Substitua myproject pelo nome que você quiser dar à pasta do projeto.

3. Crie um ambiente virtual usando o venv:

python3 -m venv env_name

4. Ative o ambiente Phyton:

source env_name/bin/activate

Uma vez ativado, o shell prompt será alterado, passando a refletir o ambiente criado (por exemplo, (env_name)), indicando que você está trabalhando neste ambiente virtual.

Essa configuração garante que todas as dependências relacionadas ao Django sejam isoladas dentro do ambiente virtual criado, mantendo seu servidor limpo e organizado.

Instale o Django

Com o ambiente virtual Python configurado, a próxima etapa é instalar o framework em si, etapa que pode ser feita através do gerenciador de pacotes do Python, o pip. A instalação do Django em seu ambiente virtual garante que ele possa ser gerenciado de forma independente.

Para instalar o Django, siga estes passos:

1. Com o ambiente virtual ativado, use o pip para instalar a versão mais recente do Django:

pip install django

2. Esse comando fará o download e a instalação da estrutura e de todas as dependências do Django no ambiente virtual.
3. Depois disso, use o seguinte comando para confirmar que o Django está instalado e para verificar a atual versão:

django-admin --version

Ao verificar a versão atual do Django instalada em seu ambiente virtual, você confirma que a instalação foi bem-sucedida.

Com sua VPS preparada para hospedar um projeto Django, você pode começar a criar sua aplicação web.

Criando um novo projeto Django

Chegou a hora de criar seu primeiro projeto usando Django. Nesta seção, vamos apresentar a base de códigos necessária para começar a desenvolver o seu site ou aplicativo.

Para criar um novo projeto Django:

1. Acesse o diretório do seu projeto: Se você ainda não estiver na pasta em que deseja criar o projeto, use o comando cd para navegar até lá.
2. Execute o comando startproject: Use o comando startproject para criar um novo projeto. Substitua myproject pelo nome que deseja dar ao seu projeto:

django-admin startproject myproject

3. Isso criará um novo diretório chamado myproject que contém a estrutura padrão do framework.
4. Em seguida, navegue até a pasta interna com o nome do seu projeto:

cd myproject/myproject

5. Adicione o IP do seu servidor à lista de hosts permitidos – ALLOWED_HOSTS: Use um dos editores de texto padrão do Ubuntu (nano ou vim) e abra o arquivo settings.py:

vim settings.py

6. Localize a configuração ALLOWED_HOSTS e edite a lista para adicionar o IP do seu VPS:

ALLOWED_HOSTS = ['ip_do_seu_vps']

7. Substitua ip_do_seu_vps pelo IP real do seu servidor VPS da Hostinger.
8. Inicie o servidor de desenvolvimento: Para verificar se tudo está configurado corretamente, você pode iniciar o servidor de desenvolvimento Django. Retorne à categoria do parent project e execute o comando runserver:

python manage.py runserver 0.0.0.0:8000

Agora, abra seu navegador e acesse http://ip_do_seu_vps:8000/ – lembrando de substituir ip_do_seu_vps pelo IP da sua VPS. Se os passos anteriores foram feitos corretamente, você deverá ver a página de boas-vindas do Django:

Se você seguiu as etapas indicadas, você acabou de construir e executar um projeto padrão do Django em sua VPS. O restante deste tutorial Django se aprofunda no desenvolvimento de aplicações e na compreensão do Django em geral.

Entendendo a estrutura de um projeto Django

A execução do comando startproject cria a estrutura básica para um projeto Django e inclui vários arquivos e diretórios importantes. Abaixo indicamos detalhadamente a estrutura e a finalidade de cada componente do framework:

Cada um desses arquivos e diretórios desempenha uma função específica em seu projeto Django:

• manage.py:

Esse é um utilitário de linha de comando que te ajuda a interagir com projetos Django. Ele é utilizado para tarefas como a execução do servidor dev, a migração de bancos de dados e o gerenciamento do aplicativo:

Suas principais funções são:

Determina a variável do ambiente para indicar ao framework Django quais arquivos de configuração devem ser utilizados.

Executa vários comandos do Django, como runserver, migrate e outros.

• myproject/:

É o diretório interno do projeto que contém as principais definições, configurações e outros arquivos padrão do seu projeto Django.

• init.py:

Esse arquivo marca o diretório como um pacote Python, permitindo que o código seja importado como um módulo em Python. Por padrão, esse elemento é instalado vazio.

• settings.py:

Esse é um dos arquivos mais importantes do Django. Ele contém todas as definições de configuração para o seu projeto, incluindo configurações de banco de dados, aplicativos instalados, middleware e configurações de arquivos estáticos.

• urls.py:

Esse diretório define os caminhos de URL para acessar sua aplicação. Ele mapeia URLs para views que fazem solicitações e retornam respostas.

Conforme adicionar mais funcionalidades ao seu projeto, você estenderá os padrões de url (urlpatterns) para incluir os caminhos de suas próprias views. 

• asgi.py:

Esse arquivo fornece um ponto de entrada para servidores web compatíveis com ASGI (Asynchronous Server Gateway Interface). Esse protocolo de comunicação entre servidores e aplicações Python é o padrão para aplicativos Django assíncronos.

• wsgi.py:

Esse arquivo é o ponto de entrada de servidores da Web compatíveis com WSGI (Web Server Gateway Interface), como o Gunicorn ou o uWSGI, para atender ao seu projeto em um ambiente de produção.

Compreender a função de cada arquivo e diretório te ajuda a modificar configurações, adicionar URLs e gerenciar a estrutura do seu projeto como um todo.

Entendendo os modelos e bancos de dados do Django

Com seu projeto Django configurado e em execução, o próximo passo é mergulhar em um dos principais componentes de qualquer programa da web: o gerenciamento de dados. Nesta seção, vamos entender como o Django lida com modelos e bancos de dados para alimentar aplicações dinâmicas e orientadas por dados.

Criando e migrando modelos

No Django, os modelos (models) definem a estrutura das tabelas do seu banco de dados. Eles representam classes Python que mapeiam diretamente as tabelas do banco de dados, permitindo que você interaja com seus dados de uma forma mais conveniente. Cada classe de cada modelo representa uma tabela, e cada atributo do modelo representa um campo da tabela.

O Django abstrai o código SQL, facilitando a criação, a atualização e o gerenciamento de bancos de dados sem que você precise escrever consultas SQL brutas.

Criando um modelo

Para criar um modelo, você definirá uma classe Python dentro do arquivo models.py de uma de suas aplicações. Cada atributo (attribute) na classe (class) corresponde a um campo do banco de dados, e o Django trabalha automaticamente com a estrutura subjacente do banco de dados.

Abaixo indicamos um exemplo de um modelo simples criado para um projeto Django:

# In your app's models.py file
from django.db import models
class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=100)
    published_date = models.DateField()
    isbn = models.CharField(max_length=13, unique=True)
    def __str__(self):
        return self.title

• title e author: são os campos de caracteres (CharField) de título e autor, e possuem limite de comprimento.
• published_date: esse é o campo de data (DateField).
• isbn: um campo de caractere com uma restrição única (unique constraint).

O método str() garante que, quando você consulta (query) um elemento, book no nosso exemplo, ele retorna o título do livro como uma representação de string.

Adicionando o modelo ao banco de dados

Depois de criar um modelo, o Django precisa traduzir esse elemento para uma tabela de banco de dados. Esse processo é feito através de migrações (migrations), que são arquivos que o Django usa para monitorar as alterações em seus modelos.

1. Crie uma migração: Para criar o arquivo migration do seu novo modelo, execute o seguinte comando:

python manage.py makemigrations

O Django vai analisar as alterações em seu arquivo models.py e gerar um arquivo de migração que descreve essas alterações em instruções estilo SQL.

Você verá outputs semelhantes a este:

Migrations for 'myapp':
  myapp/migrations/0001_initial.py
    - Create model Book

2. Efetive a migração: Depois de criar o arquivo de migration, aplique ao banco de dados com o comando migrate:

python manage.py migrate

Com isso, as tabelas necessárias estarão criadas em seu banco de dados. Agora, o modelo Book será representado por uma tabela Book correspondente em seu banco de dados, e você pode começar a adicionar, consultar e gerenciar os dados.

Configure o banco de dados

O Django suporta vários bancos de dados, permitindo que você escolha o melhor para o seu projeto. O banco de dados padrão no Django é o SQLite, que é leve e fácil de configurar, ou seja, ideal para o desenvolvimento de pequenos projetos.

No entanto, para ambientes de produção, bancos de dados mais robustos, como PostgreSQL, MySQL ou MariaDB, são as opções recomendadas, devido à sua escalabilidade e desempenho.

O Django oferece suporte integrado para todos esses bancos de dados. Vamos começar com a configuração do banco de dados padrão (SQLite).

Configurando o banco de dados padrão SQLite 

Por padrão, o Django é configurado para usar o SQLite, que vem pré-instalado com o Python. Portanto, nenhuma configuração adicional é necessária. O próximo passo é conferir se seu projeto está pronto para usar o SQLite:

1. Navegue até o arquivo settings.py do seu projeto, que deverá estar localizado na pasta do projeto (myproject→myproject→settings.py).
2. Vá para a seção DATABASES do settings.py, onde o Django já terá configurado o SQLite como o banco de dados padrão. O arquivo deve se parecer com o seguinte:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

• ENGINE: Significa “motor”, e indica o back-end do banco de dados (nesse caso, SQLite).
• NAME: se refere ao “nome” e indica o caminho para o arquivo de banco de dados SQLite (db.sqlite3). O Django cria esse arquivo automaticamente quando você executa o migrate inicial.

3. Depois de confirmar as configurações do banco de dados, é necessário aplicar as migrações iniciais para configurar as tabelas básicas (como usuários e sessões). Para isso, execute o seguinte comando:

python manage.py migrate

Esse comando cria o arquivo db.sqlite3 no diretório raiz do seu projeto e configura todas as tabelas necessárias para a execução do aplicativo.

4. Quando as migrations forem concluídas, verifique se o arquivo db.sqlite3 foi criado na pasta do projeto. Esse arquivo armazena seu banco de dados localmente e cresce à medida que você adicionar mais dados ao projeto.

Integração do banco de dados 

Depois de configurar o banco de dados SQLite para o desenvolvimento do projeto, e conforme a quantidade de dados crescer, pode ser necessário integrar um sistema de gerenciamento de banco de dados (DBMS) mais robusto. O Django suporta vários DBMSs, incluindo PostgreSQL, MySQL, MariaDB e Oracle, cada um com suas próprias vantagens e processos de configuração e integração.

Nesta seção, vamos apresentar uma visão geral de cada uma das opções:

• SQLite: Esse é o banco de dados padrão no Django e é ideal para desenvolvimento e pequenos projetos. Ele é leve, baseado em arquivos e não requer nenhuma configuração além do que o Django fornece automaticamente. No entanto, não é adequado para ambientes de produção porque não possui recursos avançados – como gravações simultâneas, escalabilidade e suporte a tráfego intenso.
  
  Instalação: O SQLite não requer nenhuma ação adicional no Django; ele vem pronto para ser usado.
  
  Configuração: O Django é pré-configurado para usar o SQLite com as seguintes configurações no arquivo settings.py:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

Note que o SQlite trabalha com apenas dois parâmetros: ENGINE e NAME.

• PostgreSQL: Um banco de dados potente e de código aberto que possui recursos avançados – como suporte a consultas complexas (complex queries), tipos de dados como JSON e pesquisa de texto completo. É altamente recomendado para aplicativos Django de produção devido à sua escalabilidade e ampla coleção de recursos. O PostgreSQL é conhecido por aderir estritamente aos padrões SQL e ser ideal para aplicativos complexos e de grande escala.
  
  Configuração: Para rodar o PostgreSQL é preciso instalar o pacote psycopg2, que atua como adaptador entre o Django e o banco de dados PostgreSQL.
  
  Configuração: Além dos parâmetros que são padrão para o SQLite, ENGINE e NAME, o PostgreSQL também requer parâmetros de usuário, senha, host e porta: USER, PASSWORD, HOST e PORT. Todos são configurados no arquivo settings.py, na seção DATABASES:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydatabase',
        'USER': 'mydatabaseuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

Diferenças: Ao contrário do SQLite, o PostgreSQL é um banco de dados com recursos completos e que suporta vários usuários simultâneos, consultas avançadas e transações. Para utilizar esse banco, é necessário instalar o PostgreSQL no servidor, criar um banco de dados e um usuário, e fazer configurações mais complexas.

• MySQL / MariaDB: Ambos são bancos de dados relacionais rápidos e confiáveis, amplamente usados no desenvolvimento web. O MySQL é conhecido por sua velocidade, enquanto o MariaDB, um fork do MySQL, é mais focado no desenvolvimento dirigido pela comunidade (community-driven development) e é totalmente compatível com o MySQL. Esses bancos de dados são excelentes para aplicações web de alto tráfego e geralmente são preferidos por seu desempenho.
  
  Configuração: O MySQL e o MariaDB usam o pacote mysqlclient para fazer interface com o Django.
  
  Configuração: Ambos usam os mesmos parâmetros do PostgreSQL, configurados no arquivo settings.py, na seção DATABASES:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',  # or 'django.db.backends.mariadb' for MariaDB
        'NAME': 'mydatabase',
        'USER': 'mydatabaseuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',
        'PORT': '3306',
    }
}

Diferenças: O MySQL e o MariaDB são conhecidos por seu desempenho com grandes conjuntos de dados e aplicações web de alto tráfego. Eles suportam vários mecanismos de armazenamento, leituras rápidas e podem lidar com milhões de queries de forma rápida.

• Oracle / Microsoft SQL Server: Esses bancos de dados são de nível empresarial e oferecem uma potência significativa, especialmente para projetos como grandes aplicativos. No entanto, sua configuração é mais complexa e, em geral, são usados apenas em ambientes empresariais específicos onde a empresa já usa o Oracle ou o SQL Server para outros softwares.
  
  Configuração: Ambos exigem drivers adicionais para fazer integração com o Django, como cx_Oracle para o Oracle e pyodbc para o SQL Server. Esses bancos de dados costumam ser usados em ambientes empresariais nos quais outros softwares de negócios já dependem desses sistemas.
  
  Configuração: Cada um desses sistemas requer processos de configuração distintos e mais complexos, incluindo instalação, a configuração de drivers e a estruturação de credenciais de banco de dados no arquivo settings.py, assim como nas opções anteriores.
  
  Diferenças: O Oracle e o SQL Server oferecem recursos de nível empresarial, como tratamento avançado de transações, desempenho otimizado e integração com sistemas de grande escala. O processo de configuração é mais complexo e geralmente é feito por administradores de banco de dados profissionais.

Agora, vamos simplificar e esclarecer os detalhes para você poder escolher o melhor banco de dados para desenvolver seu projeto Django:

• Desenvolvimento e teste: Use o SQLite. Ele é simples, não precisa de configuração adicional e é ideal para testes locais.
• Produção em pequena escala: Para aplicações web menores e de tráfego moderado, você pode escolher o MySQL ou o MariaDB, já que eles oferecem um desempenho melhor do que o SQLite e têm uma curva de aprendizado mais fácil do que o PostgreSQL.
• Produção em larga escala: O PostgreSQL é o mais recomendado para projetos Django que exigem capacidade de expansão, segurança e recursos avançados.
• Ambientes corporativos: Se você trabalha em um ambiente corporativo que usa Oracle ou SQL Server para outros aplicativos, esses bancos de dados podem ser a melhor opção devido aos requisitos de integração.

Configurando PostgreSQL com Django

Nesta seção, vamos apresentar o processo de integração do PostgreSQL com o Django, já que ele é um dos bancos de dados mais usados para desenvolvimento de aplicações.

1. Instale o PostgreSQL: Para integrar o PostgreSQL com o framework Django, o primeiro passo é instalar o PostgreSQL em seu sistema:

sudo apt update

sudo apt install postgresql postgresql-contrib

2. Instale o adaptador do PostgreSQL para Django: O Django usa o psycopg2 para se integrar com o PostgreSQL. Instale o pacote usando pip:

pip install psycopg2

3. Mude para o usuário do PostgreSQL:

sudo -u postgres psql

4. Crie um novo banco de dados:

CREATE DATABASE mydatabase;

5. Crie um usuário e senha:

CREATE USER mydatabaseuser WITH PASSWORD 'mypassword';

Conceda todos os privilégios do banco de dados ao usuário recém criado mydatabaseuser:

GRANT ALL PRIVILEGES ON DATABASE mydatabase TO mydatabaseuser;

Saia do shell do PostgreSQL:

\q

6. Configure o Django para usar o PostgreSQL: Abra o arquivo settings.py e localize a seção DATABASES. Para modificar a configuração e usar o PostgreSQL, insira:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydatabase',
        'USER': 'mydatabaseuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',  # Use '127.0.0.1' if 'localhost' doesn't work
        'PORT': '5432',       # Default PostgreSQL port
    }
}

7. Lembre-se de substituir PASSWORD e USER com a senha e usuário que você criou no Passo 5.
8. Aplique as migrações: Agora que seu banco de dados está criado e integrado, é preciso aplicar as migrações do seu projeto para configurar as tabelas necessárias no PostgreSQL:

python manage.py migrate

Esse comando cria as tabelas necessárias em seu banco de dados PostgreSQL.

9. Teste a conexão: Por fim, execute o servidor através do comando runserver para verificar se a integração do Django com o PostgreSQL foi bem-sucedida:

python manage.py runserver

Acesse a URL http://127.0.0.1:8000/ em seu navegador. Se a página de boas-vindas do Django for exibida, quer dizer que a conexão com o banco de dados está funcionando corretamente.

Com seu banco de dados PostgreSQL totalmente integrado, o framework Django poderá lidar com bases de dados maiores e mais complexas, permitindo a expansão do seu projeto.

Construindo visualizações (views) e modelos (templates)

Com o banco de dados e os modelos de gerenciamento configurados, o próximo passo é exibir essas informações aos usuários e criar interfaces interativas.

É nessa etapa que as Views (exibições) e os Templates (modelos) atuam, definindo a lógica e a estrutura por trás das páginas com as quais os usuários vão interagir.

Entendendo as visualizações

No Django, as views representam um componente essencial que define a lógica por trás do que o usuário vê quando interage com a sua aplicação.

Em termos simples, uma visualização recebe e processa uma solicitação vinda de um usuário da internet e retorna uma resposta, normalmente na forma de uma página HTML renderizada. Com o uso de modelos e templates, as exibições fazem a ponte entre o banco de dados e a interface que o usuário vê.

Dois tipos principais de visualizações no Djang são as Views baseadas em funções (FBVs) e as Views baseadas em classes (CBVs). Ambas têm o mesmo propósito, mas organizam o código de programação de maneiras diferentes.

Function-Based Views (FBVs)

As visualizações FBVs são funções Python básicas que aceitam um objeto de solicitação e retornam uma resposta. Elas costumam ser usadas para casos de navegação mais simples ou quando você precisa de mais controle sobre o fluxo do processo.

Abaixo indicamos um exemplo de uma FBV que renderiza um template HTML:

from django.shortcuts import render

# Function-based view
def homepage(request):
    return render(request, 'homepage.html')

Neste exemplo:

• request: A solicitação HTTP enviada pelo navegador do usuário.
• render: Combina o template homepage.html com qualquer dado de contexto fornecido e retorna uma resposta HTTP.

As FBVs são fáceis de entender e de implementar, mas, à medida que as views se tornam mais complexas, envolvendo formulários ou autenticação, elas podem se tornar mais difíceis de manter.

Class-Based Views (CBVs)

As visualizações baseadas em classe, por outro lado, permitem que você estruture as views de forma mais eficiente através de princípios de programação orientada a objetos. Por serem baseadas em classes Python, as CBVs são mais flexíveis e reutilizáveis.

O Django fornece views genéricas incorporadas, como ListView e DetailView, que tratam de casos mais comuns. Essas views permitem que você se concentre mais em personalizá-las em vez de reescrever lógicas repetitivas.

Veja um exemplo de CBV que executa a mesma função que o FBV anterior:

from django.views.generic import TemplateView

# Class-based view
class HomePageView(TemplateView):
    template_name = 'homepage.html'

Neste exemplo:

• TemplateView: Uma visualização genérica incorporada que renderiza um template.
• template_name: especifica o arquivo de template a ser renderizado.

Para usar esse CBV e configurar uma URL, você precisa incluir o método .as_view() ao adicioná-lo ao urls.py:

from django.urls import path
from .views import HomePageView

urlpatterns = [
    path('', HomePageView.as_view(), name='home'),
]

Quando usar FBVs e quando usar CBVs

• Use FBVs quando precisar de simplicidade e controle total sobre a lógica de visualização. As views baseadas em funções costumam ser mais intuitivas para views não complexas ou para lógicas personalizadas que não se encaixam nos padrões de visualização predefinidos pelo Django.
• Use CBVs quando você quiser seguir os princípios DRY (Don’t Repeat Yourself) e reutilizar a lógica existente. As CBVs são ideais quando as views aumentam em complexidade, como ao lidar com formulários, dados paginados ou operações CRUD padrão.

Tanto as visualizações FBVs quanto CBVs são partes constituintes do Django, e a escolha entre eles depende dos requisitos do seu projeto e da sua preferência pessoal.

Trabalhando com templates

O sistema de templates, ou modelos, do Django foi projetado para separar a apresentação dos dados da lógica subjacente a ela. Templates são essencialmente arquivos HTML que contêm conteúdos dinâmicos, permitindo exibir os dados processados a partir das views. Para inserir dados dinâmicos numa página HTML, a Django Template Language (DTL) oferece placeholders (textos de preenchimento) e lógicas de visualização, como loops e condicionais.

Os templates desempenham um papel central na aparência das páginas web, mantendo uma separação clara entre a lógica, que é tratada pelas views, e a interface do usuário.

Criando um Template

Para usar um template no Django, você precisa criar um arquivo HTML dentro do diretório chamado templates. Abaixo apresentamos um exemplo da estrutura do diretório:

myproject/
│
├── myapp/
│   ├── templates/
│   │   └── myapp/
│   │       └── homepage.html
│   └── views.py
│
└── manage.py

Na estrutura acima, o Django procura automaticamente por templates dentro do diretório templates do seu app. Você pode organizar ainda mais os templates dentro de pastas específicas da sua aplicação (como myapp/homepage.html), garantindo que cada aplicação terá seus próprios templates.

Confira um exemplo de um template simples para página inicial (homepage.html):

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Home</title>
</head>
<body>
    <h1>Welcome to {{ site_name }}</h1>
    <p>{{ message }}</p>
</body>
</html>

Neste template, {{ site_name }} e {{ message }} são placeholders que serão preenchidos com dados dinâmicos a partir da view.

Renderizando um template em uma view

Para renderizar um template para a visualização dos usuários, é preciso usar a função render() do Django. Abaixo indicamos como renderizar o template homepage.html com alguns dados de contexto em uma view baseada em função – function-based view (FBV):

from django.shortcuts import render

def homepage(request):
    context = {
        'site_name': 'My Django Website',
        'message': 'This is the homepage content!'
    }
    return render(request, 'myapp/homepage.html', context)

Neste exemplo:

• render(): Combina o template (homepage.html) com os dados de contexto.
• context: Um dicionário contendo os dados de nome e mensagem (site_name and message), que serão inseridos no template. 

Quando um usuário acessar a página, os placeholders {{ site_name }} e {{ message }} do template serão substituídos por “My Django Website” e “This is the homepage content!”, respectivamente.

Tags e filtros de template

Os templates do Django também suportam tags e filtros, que permitem adicionar conteúdos dinâmicos e lógicas de visualização dentro de arquivos HTML.

• Template Tags: Executam a lógica dentro dos templates, como loops e condicionais. Por exemplo, uma condição “se” (if condition):

{% if user.is_authenticated %}
    <p>Welcome back, {{ user.username }}!</p>
{% else %}
    <p>Hello, Guest!</p>
{% endif %}

• Filtros de Template: Modificam variáveis de exibição. Por exemplo, é possível definir datas com um filtro:

<p>Published on {{ article.published_date|date:"F j, Y" }}</p>

Estendendo templates

O Django suporta herança de templates, isso é, é possível criar templates-base que podem ser usados para criar outros templates (extend template). Esse recurso é útil para manter um layout consistente em todas as páginas, como cabeçalhos e rodapés padrão.

1. Crie um template-base (base.html):

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{% block title %}My Site{% endblock %}</title>
</head>
<body>
    <header>
        <h1>Site Header</h1>
    </header>

    <main>
        {% block content %}
        <!-- Page-specific content goes here -->
        {% endblock %}
    </main>

    <footer>
        <p>Footer Content</p>
    </footer>
</body>
</html>

2. Estenda o template base em um novo template (homepage.html):

{% extends 'base.html' %}

{% block title %}Home Page{% endblock %}

{% block content %}
    <h2>Welcome to the homepage!</h2>
    <p>This is the homepage content.</p>
{% endblock %}

Ao estender o template base, você pode reutilizar o cabeçalho e o rodapé em diferentes páginas, garantindo um layout consistente sem precisar fazer repetições.

Usando arquivos estáticos em templates

Os templates também permitem referenciar arquivos estáticos (como CSS, JavaScript ou imagens) usando a tag {% static %}. Por exemplo, para incluir um arquivo CSS:

<link rel="stylesheet" type="text/css" href="{% static 'css/style.css' %}">

Lembre-se de configurar corretamente os diretórios de arquivos estáticos no settings.py:

STATIC_URL = '/static/'

Utilizando o sistema de templates do Django, você pode criar páginas dinâmicas e baseadas em dados, mantendo uma separação limpa entre a lógica ou estrutura e a apresentação ou visualização.

Trabalhando com Padrões de URL

O dispatcher de URL do Django se baseia em expressões regulares ou conversores de caminho (convert-path) para combinar solicitações de URL com views específicas. Esses padrões de URL são definidos no diretório urls.py, e o Django usa essa configuração para determinar qual view deve responder à requisição.

Cada projeto Django costuma ter dois níveis de configuração de URL:

• URLs a nível do projeto: Definido no arquivo raiz urls.py (localizado no diretório principal do projeto), esse arquivo contém a estrutura geral do roteamento de URLs do projeto.
• URLs a nível do app: Cada aplicação dentro do seu projeto pode ter seu próprio arquivo urls.py, permitindo o gerenciamento modular de URLs. Estas URLs ao nível da aplicação são posteriormente conectadas às URLs a nível do projeto.

Configuração básica de URL

Veja um exemplo de como configurar padrões de URL em um projeto simples:

1. URLs a nível de projeto (myproject→urls.py)

from django.contrib import admin
from django.urls import path, include
urlpatterns = [
    path('admin/', admin.site.urls),  # Admin site
    path('', include('myapp.urls')),  # Include app-level URLs for "myapp"

]

• path(): A função de caminho do Django para definir padrões de URL.
• admin.site.urls: Lida com todas as requisições relacionadas à administração da aplicação.
• include(): Função usada para incluir URLs a nível da aplicação (a partir do diretório myapp.urls) nas configurações principais do projeto.

2. URLs a nível da aplicação (myproject→myapp→urls.py)

from django.urls import path
from . import views

urlpatterns = [
    path('', views.homepage, name='home'),  # Maps the root URL to the homepage view
    path('about/', views.about, name='about'),  # Maps "/about/" to the about view

]

• A URL raiz (root URL, representado por ‘ ‘) faz referência à view da página inicial.
• A URL /about/ URL faz referência à view da página sobre (about)

Roteamento de URL com views baseadas em funções (FBVs)

Abaixo demonstramos como as views correspondentes às configurações de URL acima podem aparecer no arquivo views.py:

from django.shortcuts import render

def homepage(request):
    return render(request, 'homepage.html')

def about(request):
    return render(request, 'about.html')

Esta configuração conecta as URLs homepage e about às suas respectivas views, garantindo que quando um usuário visita as URLs http://example.com/ ou http://example.com/about/, a página renderiza e exibe o template correto.

Roteamento de URL com views baseadas em classes (CBVs)

Também é possível mapear URLs para visualizações class-based (CBVs), que exigem uma configuração um pouco diferente. Abaixo indicamos um exemplo de mapping de URL CBV:

from django.urls import path
from .views import HomePageView, AboutPageView

urlpatterns = [
    path('', HomePageView.as_view(), name='home'),
    path('about/', AboutPageView.as_view(), name='about'),
]

Respectivamente, confira como se estruturam as visualizações baseadas em classe no arquivo views.py:

from django.views.generic import TemplateView

class HomePageView(TemplateView):
    template_name = 'homepage.html'

class AboutPageView(TemplateView):
    template_name = 'about.html'

Neste caso, o método .as_view() é utilizado para conectar as views baseadas em classes aos padrões de URL determinados.

Parâmetros de URL e roteamento dinâmico

O framework Django também permite capturar parâmetros de URL e passá-los para as views, recurso especialmente útil no mapeamento de URLs dinâmicas, como em blog posts ou páginas de produtos em lojas virtuais.

Aqui está um exemplo no qual a URL se conecta a um parâmetro integer, ou inteiro:

from django.urls import path
from . import views

urlpatterns = [
    path('article/<int:id>/', views.article_detail, name='article_detail'),
]

Neste caso, a função <int:id> captura o integer a partir da URL e o passa para a view article_detail como um argumento:

def article_detail(request, id):
    # Fetch the article using the provided ID
    article = get_object_or_404(Article, pk=id)
    return render(request, 'article_detail.html', {'article': article})

Se um usuário visitar a URL http://example.com/article/5/, o Django passará 5 como o argumento id para a view article_detail, permitindo que o servidor localize e exiba o artigo específico.

Padrões de URL nomeados

É uma boa prática nomear seus padrões de URL. Isto permite referenciar as URLs pelos seus nomes nos modelos e views em vez de ter que codificar os padrões repetitivamente.

No exemplo urls.py acima, cada URL tem um argumento de nome:

path('about/', views.about, name='about')

Em seus templates, você pode usar a tag de template {% url %} para fazer referência às URLs nomeadas: 

<a href="{% url 'about' %}">Sobre Nós</a>

Dessa forma, se a URL about mudar, você só precisa atualizar o endereço na configuração da URL e não em cada um dos templates.

Ao configurar e trabalhar com padrões de URL no Django, você pode rastrear diferentes URLs para suas respectivas views. Essa flexibilidade permite que você apresente tanto páginas estáticas simples quanto conteúdos mais complexos e dinâmicos que variam de acordo com o input do usuário.

Gerenciando Arquivos Estáticos no Django

Agora que você já sabe como configurar views, templates, e padrões de URL, para construir uma aplicação Django totalmente funcional, também é preciso gerenciar arquivos estáticos como CSS, JavaScript e imagens.

Felizmente, o framework Django oferece formas simples e eficientes de gerenciar arquivos estáticos, garantindo que eles sejam organizados e exibidos corretamente durante o desenvolvimento e lançamento da aplicação.

Configurando arquivos estáticos no Django

Para gerenciar arquivos estáticos no Django, você precisa configurar seu projeto para ele saber onde procurar e exibir tais arquivos.

Defina a URL estática e o Diretório em settings.py:

# settings.py
STATIC_URL = '/static/'
STATICFILES_DIRS = [
    BASE_DIR / "static",  # Optional: Add this if you want to store static files in a 'static' folder within your project
]

• STATIC_URL: Define o prefixo da URL que o Django deve usar quando retornar arquivos estáticos às solicitações.
• STATICFILES_DIRS: Define diretórios adicionais nos quais o Django irá localizar arquivos estáticos durante o desenvolvimento do projeto.

Por padrão, o Django também procura arquivos estáticos dentro do diretório estático (static) de cada aplicação. Por exemplo, se você tem um app chamado myapp, é possível criar uma estrutura de pastas como essa:

myapp/
│
├── static/
│   └── myapp/
│       └── style.css
└── views.py

O Django automaticamente reconhece e serve esses arquivos durante o desenvolvimento.

Usando arquivos estáticos em templates

Para usar arquivos estáticos em seus templates, o primeiro passo é carregar a tag de template {% static %} do Django. Depois, você pode referenciar seus arquivos estáticos pelos seus respectivos caminhos (paths):

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Home Page</title>
    {% load static %}
    <link rel="stylesheet" href="{% static 'myapp/style.css' %}">
</head>
<body>
    <h1>Welcome to My Django App</h1>
    <img src="{% static 'myapp/images/logo.png' %}" alt="Logo">
</body>
</html>

Nesse exemplo:

• {% load static %}: Carrega a tag de template dos arquivos estáticos.
• {% static ‘myapp/style.css’ %}: Indica o caminho para o arquivo style.css no diretório static/myapp.
• {% static ‘myapp/images/logo.png’ %}: Resolve o caminho para um arquivo de imagem.

Coletando arquivos estáticos para deployment

Durante o desenvolvimento, o Django serve arquivos estáticos automaticamente quando DEBUG = True. No entanto, em produção, o Django não serve arquivos estáticos de forma automática. Nesse caso, é preciso coletar todos os arquivos estáticos de vários locais e armazená-los em um único diretório.

Para fazer isso, utilize o comando de gerenciamento collectstatic:

1. O comando django.contrib.staticfiles deve estar incluído na configuração INSTALLED_APPS:

INSTALLED_APPS = [
    # Other installed apps
    'django.contrib.staticfiles',
]

2. Configure o Diretório Raiz Estático em settings.py:

STATIC_ROOT = BASE_DIR / 'staticfiles'

STATIC_ROOT: Caminho que define o diretório onde o Django deverá coletar arquivos estáticos para deployment.

3. Execute o comando collectstatic:

python manage.py collectstatic

Este comando coleta todos os arquivos estáticos de cada diretório estático da aplicação e de qualquer outro local especificado em STATICFILES_DIRS, armazenando-os conjuntamente no diretório STATIC_ROOT.

Servindo arquivos estáticos na produção

Em um ambiente de produção, geralmente utilizamos um servidor web (como Nginx ou Apache) para servir arquivos estáticos. O framework recomenda configurar o servidor para servir conteúdo estático eficientemente, reduzindo a carga da aplicação Django.

Confira um exemplo de como configurar a exibição de arquivos estáticos em um ambiente Nginx:

1. Configuração do Nginx para arquivos estáticos:

server {
    listen 80;
    server_name yourdomain.com;
    location /static/ {
        alias /path/to/your/project/staticfiles/;  # The path to STATIC_ROOT
    }
    location / {
        proxy_pass http://127.0.0.1:8000;  # Pass requests to Django app
    }
}

Nesta configuração, o Nginx automaticamente serve arquivos estáticos a partir do diretório /static/, enquanto encaminha todas as outras solicitações para o aplicativo Django.

Gerenciando corretamente seus arquivos estáticos no Django, você garante que sua aplicação terá um bom aspecto em termos de estilo e imagens, e também um funcionamento eficiente quando lançada.

Implementando autenticação e autorização de usuários

Conforme o desenvolvimento de suas aplicações se torna mais dinâmico e complexo, a necessidade de gerenciar usuários, proteger conteúdos e controlar acessos se torna fundamental.

O Django conta com um sistema de autenticação integrado que facilita o gerenciamento de login, logout, cadastro e permissões de usuários. Esses recursos permitem que o desenvolvedor do projeto Django gerencie eficientemente tanto a autenticação quanto a autorização de diferentes usuários.

Autenticação de usuários

O sistema de autenticação do Django simplifica a administração de usuários pelos recursos como login, logout, gerenciamento de senhas e cadastros. Por padrão, o Django oferece a funcionalidade de modelos de usuário e views de autenticação que lidam com a maioria dessas tarefas.

Configurando login e logout de usuários

Para implementar a funcionalidade de login e logout, você pode usar as views integradas do framework, encontradas em django.contrib.auth.views. Essas views lidam com o processo de autenticação e simplificam o código necessário para processar essas operações.

1. Configure as URLs para login e logout no arquivo urls.py:

from django.urls import path
from django.contrib.auth import views as auth_views

urlpatterns = [
    path('login/', auth_views.LoginView.as_view(), name='login'),
    path('logout/', auth_views.LogoutView.as_view(), name='logout'),
]

• LoginView: se refere ao login do usuário.
• LogoutView: faz o logout e redireciona o usuário para a página especificada.

2. Crie um template de formulário de login: Você pode criar um modelo de login simples (login.html) no diretório de templates da sua aplicação:

<form method="post">
    {% csrf_token %}
    <div>
        <label for="username">Username:</label>
        <input type="text" id="username" name="username" required>
    </div>
    <div>
        <label for="password">Password:</label>
        <input type="password" id="password" name="password" required>
    </div>
    <button type="submit">Login</button>
</form>

Este template irá lidar com a autenticação do visitante quando ele inserir um usuário e uma senha válidos.

3. Criar logout: Não é preciso criar um template específico para fazer logout, já que o LogoutView do Django faz isso automaticamente. Você pode simplesmente adicionar um link de logout no template:

<a href="{% url 'logout' %}">Logout</a>

Criando uma View de Cadastro de Usuário

Por padrão, o Django não conta uma view de registro ou cadastro integrada, mas você pode criar uma utilizando o UserCreationForm do Django:

1. Crie uma view de registro no arquivo views.py:

from django.shortcuts import render, redirect
from django.contrib.auth.forms import UserCreationForm
from django.contrib.auth import login

def register(request):
    if request.method == 'POST':
        form = UserCreationForm(request.POST)
        if form.is_valid():
            user = form.save()
            login(request, user)  # Automatically log the user in after registration
            return redirect('home')  # Redirect to home page after successful registration
    else:
        form = UserCreationForm()
    return render(request, 'register.html', {'form': form})

2. Configure a URL para cadastro no urls.py:

urlpatterns = [
    path('register/', views.register, name='register'),
]

3. Crie o template de formulário para registo (register.html):

<form method="post">
    {% csrf_token %}
    {{ form.as_p }}
    <button type="submit">Register</button>
</form>

Esta view de cadastro permite que o usuário crie uma conta através de um formulário simples. Depois do registo, a sessão do usuário é automaticamente iniciada.

Autorização de usuário 

A autorização de um usuário permite controlar o acesso dele a certas views e ações com base nas permissões ou funções de usuário. O sistema de permissões do Django facilita o gerenciamento dos usuários e seus acessos a partes específicas da aplicação.

Restringindo o acesso com solicitação de login 

Para restringir o acesso a certas views, você pode usar o decorator do Django @login_required, assim, apenas usuários autenticados com login podem acessar uma visualização:

1. Usando @login_required em views:

from django.contrib.auth.decorators import login_required

@login_required
def dashboard(request):
    return render(request, 'dashboard.html')

Isso garante que se um usuário não estiver logado, ele será automaticamente redirecionado para a página de login.

2. Aplicando o @login_required em URLs específicas: Alternativamente, você pode usar o @login_required diretamente no arquivo urls.py através do LoginRequiredMixin para views baseadas em classe (CBVs):

from django.contrib.auth.mixins import LoginRequiredMixin
from django.views.generic import TemplateView

class DashboardView(LoginRequiredMixin, TemplateView):
    template_name = 'dashboard.html'

Gerenciamento de permissões de usuário

O Django permite que você atribua diferentes permissões a usuários e grupos de usuários, que podem ser usadas para controlar o acesso a visualizações ou ações específicas. As permissões podem ser adicionadas aos modelos de usuário e gerenciadas nas views.

1. Atribuição de permissões: Ao criar usuários ou grupos de usuários, é possível atribuir permissões a eles. Por exemplo, um usuário administrador pode ter permissão para adicionar ou excluir conteúdos, enquanto os usuários comuns só podem visualizar o conteúdo.
2. Verificação de permissões em views: Você pode verificar se um usuário tem as permissões necessárias antes de permitir o acesso a determinadas views usando o decorator @permission_required:

from django.contrib.auth.decorators import permission_required

@permission_required('app.add_article')
def add_article(request):
    # View code for adding an article

Nesse caso, somente os usuários com a permissão add_article poderão acessar a visualização indicada.

Restringir o acesso com base nas funções do usuário

O recurso de grupos do Django permite que você crie funções (como “editor” ou “visualizador”) e atribua usuários a esses grupos. A partir disso, você pode gerenciar a participação de um usuário a um grupo específico para controlar o acesso.

1. Atribuindo usuários aos grupos: Os grupos podem ser criados no painel de administração do Django ou de forma programática:

from django.contrib.auth.models import Group, User

group = Group.objects.get(name='editors')
user = User.objects.get(username='john')
user.groups.add(group)  # Assign the user to the 'editors' group

2. Configurando o acesso dos grupos nas views: Você pode restringir as visualizações com base no grupo:

from django.contrib.auth.decorators import user_passes_test

def is_editor(user):
    return user.groups.filter(name='editors').exists()

@user_passes_test(is_editor)
def editor_dashboard(request):
    return render(request, 'editor_dashboard.html')

Neste exemplo, somente os usuários que pertencem ao grupo “editores” podem acessar a visualização do painel de edição, o editor_dashboard.

Utilizando os sistemas integrados de autenticação e autorização do Django, você pode gerenciar o login, o cadastro e as permissões dos usuários com segurança, garantindo que conteúdos sensíveis estarão protegidos e que o acesso será liberado ou limitado de acordo com o caso.

Trabalhando com formulários no Django

Depois de implementar os serviços de autenticação e autorização de usuários, o próximo recurso a ser gerenciado em uma página web são os inputs dos usuários pelos formulários. O Django conta com um sistema potente e flexível para criar, processar e validar formulários.

O sistema de formulários do Django é baseado em classes Python que tratam formulários como objetos. Esses formulários podem ser renderizados em templates, validados e processados através de algumas poucas linhas de código. Os formulários podem ser criados manualmente com a classe Form do Django ou gerados automaticamente a partir de modelos do ModelForm.

Criando Formulários com a Classe “Form” do Django

Para criar um formulário usando o framework Django, é preciso primeiro definir uma classe de formulário no arquivo forms.py. Essa classe define os campos e as regras de preenchimento e validação do formulário.

1. Definindo um formulário: este é um exemplo de formulário de contato simples:

# forms.py
from django import forms
class ContactForm(forms.Form):
    name = forms.CharField(max_length=100, label='Seu Nome')
    email = forms.EmailField(label='Seu Email')
    message = forms.CharField(widget=forms.Textarea, label='Sua Mensagem')

Esse formulário inclui três campos: nome, email e mensagem. Cada campo é representado por uma classe de campo de preenchimento, como CharField para texto curto, EmailField para endereços de email e Textarea para entradas de texto mais longas.

2. Renderizando o formulário em um template: Para exibir o formulário na página de contato, é necessário fazer a renderização dele dentro de um template. Você pode renderizar o formulário manualmente ou utilizar os recursos de renderização de formulário integrados ao Django:

<form method="post">
    {% csrf_token %}
    {{ form.as_p }}
    <button type="submit">Enviar Mensagem</button>
</form>

• {% csrf_token %}: Adiciona um token CSRF para proteger contra ataques de falsificação de solicitações entre sites (Cross-Site Request Forgery).
• {{ form.as_p }}: Renderiza os campos do formulário com cada campo correspondendo a uma tag <p> para facilitar a personalização.

3. Lidando com envios de formulários: Na exibição que lida com o envio do formulário, você precisa validar e processar os dados do formulário, caso ele seja válido:

# views.py
from django.shortcuts import render
from .forms import ContactForm

def contact_view(request):
    if request.method == 'POST':
        form = ContactForm(request.POST)
        if form.is_valid():
            # Process the data, e.g., send an email or save it to the database
            name = form.cleaned_data['name']
            email = form.cleaned_data['email']
            message = form.cleaned_data['message']
            # Redirect to a success page or show a success message
            return render(request, 'thanks.html')
    else:
        form = ContactForm()
    return render(request, 'contact.html', {'form': form})

Nesta view:

• Se o formulário for enviado por meio de uma solicitação POST, os dados do formulário serão validados.
• form.is_valid(): A função verifica se os dados do formulário foram aprovados na etapa de validação.
• form.cleaned_data: Contém os dados de formulário que foram validados e que agora podem ser processados (por exemplo, enviando um email).
• Se a solicitação não for do tipo POST, um formulário vazio será exibido para o usuário preencher.

Validação de formulários e correção de erros

Os formulários do Django contam com um sistema de validação integrado que garante que os dados enviados estejam corretos e seguros. A validação de campos como EmailField indica se o usuário preencheu um endereço de email válido. Você também pode criar uma lógica de validação personalizada para aplicar regras específicas aos formulários.

Validação padrão

O Django executa automaticamente algumas validações:

• Campos obrigatórios: Por padrão, todos os campos são obrigatórios, a menos que você especifique required=False.
• Tipos de campo de preenchimento: Campos como EmailField, IntegerField e URLField validam automaticamente o tipo de dados inseridos.

Validação personalizada

Você também pode definir uma lógica de validação personalizada para seus formulários, basta sobrescrever o método clean() ou criar validadores de campo personalizados.

1. Adicionando um validador personalizado para o campo de nome (name):

# forms.py
from django import forms
from django.core.exceptions import ValidationError
class ContactForm(forms.Form):
    name = forms.CharField(max_length=100, label='Seu Nome')
    email = forms.EmailField(label='Seu Email')
    message = forms.CharField(widget=forms.Textarea, label='Sua Mensagem')
    def clean_name(self):
        name = self.cleaned_data.get('name')
        if "spam" in name.lower():
            raise ValidationError("Invalid name: 'spam' is not allowed.")
        return name

Nesse exemplo, se o nome contiver a palavra spam, o Django irá retornar um erro de validação.

2. Corrigindo erros de formulário: Você pode personalizar como os erros de formulário são exibidos nos templates. O Django adiciona mensagens de erro em cada campo preenchido incorretamente e você pode exibir as mensagens desta forma:

<form method="post">
    {% csrf_token %}
    <div>
        {{ form.name.label_tag }} {{ form.name }}
        {% if form.name.errors %}
            <div class="error">{{ form.name.errors }}</div>
        {% endif %}
    </div>
    <div>
        {{ form.email.label_tag }} {{ form.email }}
        {% if form.email.errors %}
            <div class="error">{{ form.email.errors }}</div>
        {% endif %}
    </div>
    <div>
        {{ form.message.label_tag }} {{ form.message }}
        {% if form.message.errors %}
            <div class="error">{{ form.message.errors }}</div>
        {% endif %}
    </div>
    <button type="submit">Send Message</button>
</form>

Isso faz com que a página exiba mensagens de erro ao lado dos campos de preenchimento que os usuários precisam corrigir.

Criando Formulários a partir de Modelos Usando o ModelForm

Em muitos casos, os formulários estão vinculados a modelos. Com o Django, é fácil criar formulários a partir de modelos usando o ModelForm. Essa técnica economiza seu tempo pois automaticamente gera os campos do formulário de acordo com os campos do modelo.

1. Criando um ModelForm: Neste exemplo, você tem um modelo Post no arquivo models.py:

# models.py
from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

Você pode criar um formulário para esse modelo assim:

# forms.py
from django import forms
from .models import Post

class PostForm(forms.ModelForm):
    class Meta:
        model = Post
        fields = ['title', 'content']

2. Usando o ModelForm em uma view:

# views.py
from django.shortcuts import render
from .forms import PostForm

def create_post(request):
    if request.method == 'POST':
        form = PostForm(request.POST)
        if form.is_valid():
            form.save()  # Saves the form data to the database
            return redirect('post_list')  # Redirect to a list of posts
    else:
        form = PostForm()
    return render(request, 'create_post.html', {'form': form})

Ao usar o ModelForm, o Django gera campos de formulário automaticamente com base nos campos do modelo Post e salva o formulário no banco de dados.

Fazendo o Deployment de uma Aplicação Django

Depois que o projeto estiver totalmente desenvolvido e testado no seu servidor local, a etapa final é fazer o lançamento da aplicação em um servidor live para que os usuários possam acessar. O deploy, ou implantação, de um projeto Django exige cuidado e atenção às práticas recomendadas para garantir a segurança, a escalabilidade e o desempenho do projeto. Nesta seção, vamos apresentar as etapas básicas de publicação do seu app em uma VPS.

Práticas pecomendadas para o deployment de um projeto Django

Antes de começar com as etapas técnicas, é importante seguir algumas boas práticas para preparar seu projeto Django:

1. Use variáveis de ambiente: As environment variables servem para armazenar informações confidenciais, como senhas, credenciais de banco de dados e chaves de API – assim você não precisa codificar esses dados nas suas configurações.
2. Desabilite o modo de depuração: Defina DEBUG = False em seu arquivo settings.py antes de fazer o deploy do seu projeto. O modo debug pode vazar informações confidenciais a invasores.
3. Defina os hosts permitidos: No arquivo settings.py, defina o parâmetro ALLOWED_HOSTS para incluir o(s) nome(s) de domínio em que a aplicação estará hospedada. Por exemplo:

ALLOWED_HOSTS = ['seudominio.com', 'www.seudominio.com']

4. Proteja a aplicação: Considere usar o protocolo HTTPS para transferir dados entre o servidor e os usuários de forma segura, e use as configurações de segurança integradas do Django, como SECURE_SSL_REDIRECT, CSRF_COOKIE_SECURE, e SESSION_COOKIE_SECURE.
5. Verifique os arquivos estáticos: Arquivos estáticos, como CSS e JavaScript, devem ser coletados e servidos da forma correta. O Django fornece o comando collectstatic para lidar com esses arquivos.
6. Configuração do banco de dados: Seu banco de dados deve estar configurado corretamente, lembrando de evitar o uso do SQLite para produção – nesse caso, opte por um banco de dados mais robusto, como PostgreSQL ou MySQL.

Deploy do Django em uma VPS

Agora que você já conhece as boas práticas para preparar o lançamento do seu projeto Django, é hora de implantá-lo em um servidor virtual privado (VPS). Nesta seção, vamos indicar as etapas de configuração do servidor e dos serviços necessários para colocar seu aplicativo Django no ar e torná-lo acessível aos usuários.

Criando um arquivo Python requirements.txt

O arquivo requirements.txt lista todas as dependências Python necessárias para rodar seu projeto Django. Esse arquivo permite que você instale todos os pacotes necessários com um único comando.

Lembre-se de ativar o ambiente virtual e acessar o diretório principal do seu projeto, onde está o arquivo manage.py.

Em seguida, crie o arquivo requirements.txt com o seguinte comando:

pip3 freeze > requirements.txt

Esse comando cria um arquivo requirements.txt no diretório atual já com todos os pacotes e versões que estão instalados em seu ambiente virtual.

Depois disso, abra o arquivo requirements.txt e verifique se todas as dependências Python necessárias para executar seu projeto estão listadas.

Fazendo o upload do projeto num repositório remoto (GitHub)

Antes de fazer o deploy do seu projeto na VPS, uma prática muito recomendada é fazer o upload do seu código em um repositório remoto, como o GitHub. Isso permite que você controle as versões da aplicação, facilite o trabalho entre colaboradores do projeto e simplifique o próprio processo de deployment.

1. Instale a interface (CLI) do Git e crie um repositório local. Verifique se você está na pasta principal do projeto, onde está o arquivo manage.py, e execute estes comandos:

sudo apt install git-all

git init

2. Crie um arquivo .gitignore e adicione o conteúdo a ele. O arquivo .gitignore informa ao Git quais arquivos devem ser ignorados ao enviar o código para o repositório remoto. Isso é feito para evitar que arquivos com informações confidenciais e arquivos locais irrelevantes, como logs, sejam publicados. Aqui está um exemplo de arquivo .gitignore para um projeto Django:

venv/
__pycache__/
db.sqlite3
*.pyc
*.log
media/

3. Lembre-se de limpar as informações confidenciais no arquivo settings.py, como senhas e nomes de usuário. Depois que o projeto for lançado, você poderá adicionar as credenciais à VPS.
4. Adicione e confirme (Commit) seus arquivos.

git add .

git commit -m "Initial commit"

5. Faça seu cadastro e login no GitHub e crie um novo repositório remoto, defina o status como privado e copie seu link.
6. Configure a origem (origin) e o ramo (branch) do repositório Git.

git remote add origin https://github.com/url-do-repositorio-criado

git branch -M main

7. Verifique o status do seu repositório local e faça o push dos arquivos. Antes de fazer esse envio, você deve executar o comando status para garantir que os arquivos que não devem ser publicados não tenham sido adicionados ao repositório:

git status

8. Confirme que apenas os arquivos que você deseja publicar foram adicionados e faça o push deles para o repositório remoto:

git push -u origin main

9. Acesse seu repositório remoto no GitHub e verifique os arquivos enviados.

Prepare sua VPS e recupere (retrieve) o código do projeto

O próximo passo é preparar seu servidor virtual para o deployment e fazer o download do código da aplicação nele:

1. Acesse seu VPS via SSH

ssh root@ip_do_seu_vps

2. Instale o Nginx e o Gunicorn

sudo apt install nginx

sudo pip3 install gunicorn

Usaremos o Nginx como servidor web e o Gunicorn como servidor da aplicação.

3. Recupere o código a partir do GitHub

git clone https://github.com/seu-repositorio/nome-do-projeto.git

cd nome-do-projeto

4. Inicie um ambiente virtual e instale as dependências necessárias

python3 -m venv env_namesource env_name/bin/activate

pip3 install -r requirements.txt

5. Insira os dados sensíveis de volta no arquivo settings.py
6. Rode as migrações (migrations) e colete os arquivos estáticos

python manage.py migrate

python manage.py collectstatic

7. Configure o Gunicorn como o servidor de aplicação. Crie um arquivo de serviços:

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

Adicione a seguinte configuração:

[Unit]
Description=gunicorn daemon
After=network.target

[Service]
User=your-username
Group=www-data
WorkingDirectory=/your/project/directory
ExecStart=/your/project/directory/env_name/bin/gunicorn --access-logfile - --workers 3 --bind unix:/your/project/directory.sock myproject.wsgi:application

[Install]
WantedBy=multi-user.target

Lembre-se de substituir os campos de your-username e /your/project/directory com os valores reais do seu nome de usuário e do caminho do diretório do seu projeto.

8. Inicie e habilite o Gunicorn

sudo systemctl start gunicorn

sudo systemctl enable gunicorn

9. Configure o Nginx como servidor web. Crie um arquivo de configuração:

sudo nano /etc/nginx/sites-available/myproject

Adicione a seguinte configuração:

server {
    listen 80;
    server_name yourdomain.com www.yourdomain.com;

    location / {
        proxy_pass http://unix:/your/project/directory/project-name.sock;
        proxy_set_header Host $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;
    }

    location /static/ {
        alias /your/project/directory/static/;
    }

    location /media/ {
        alias /your/project/directory/media/;
    }
}

Lembre-se de substituir o campo /your/project/directory com o caminho real do diretório do seu projeto.

10. Habilite o site e reinicie o Nginx

sudo ln -s /etc/nginx/sites-available/myproject /etc/nginx/sites-enabled

sudo systemctl restart nginx

11. Proteja o servidor com SSL: usaremos o Certbot para adicionar um certificado SSL e redirecionar o tráfego de HTTP para HTTPS:

sudo apt install certbot python3-certbot-nginxsudo certbot --nginx -d yourdomain.com -d www.yourdomain.com

Seguindo esses passos, você pode lançar seu projeto Django em uma VPS sem maiores erros, garantindo a segurança da aplicação e um bom desempenho.

Com o Nginx e o Gunicorn cuidando da transferência de dados entre a web e o servidor, sua aplicação está pronta para lidar com tráfego ativo. Visite seu domínio e, se tiver configurado tudo corretamente, você verá sua aplicação ativa.

Conclusão

Neste tutorial Django, apresentamos as etapas essenciais para começar a usar o framework, desde a configuração do ambiente de desenvolvimento até o deployment do projeto em um servidor virtual privado (VPS). O passo-a-passo mostrou como criar um projeto, gerenciar modelos, armazenar dados, criar views e templates, trabalhar com URLs e com arquivos estáticos, implementar autenticação de usuário e publicar sua aplicação em um servidor ativo.

Com esses conhecimentos básicos, agora você estará preparado para começar a criar seus próprios projetos com o framework Django. Seja um simples blog ou um aplicativo mais complexo, o Django fornece as ferramentas necessárias para dar vida às suas ideias. Mergulhe de cabeça, experimente e veja o que é possível criar com esse poderoso framework.

Perguntas frequentes sobre Django