Criando Modelos Django: Um Tutorial

Hark Labs2022-03-08 · 13 min read

Django é um framework web bem conhecido para o desenvolvimento rápido de sites e aplicativos web seguros e de fácil manutenção. Construído usando Python, o Django simplifica o desenvolvimento web, permitindo mais tempo e foco na escrita de aplicativos sem reinventar a roda a cada momento. O Django é um projeto gratuito e de código aberto com documentação oficial robusta, excelente suporte da comunidade e bastante suporte gratuito e pago.

Neste guia, vamos mergulhar na criação de modelos do Django. No Django, um modelo é a principal fonte de informações sobre seus dados. Os modelos descrevem os campos e o comportamento dos dados a serem armazenados. O Django usa o modelo para gerar as tabelas do banco de dados usando ORM (Object Relational Mapping), também referidos como modelos.

Pré-requisitos

Estamos trabalhando em um sistema operacional baseado em Unix, de preferência um servidor em nuvem Ubuntu 20.04 como o sistema no qual testamos. Se você deseja configurar o Django em um ambiente semelhante, consulte nosso tutorial, “Como Instalar o Django e Configurar um Ambiente de Desenvolvimento no Ubuntu 20.04.”

Passo 1. Ambiente de Desenvolvimento Python

O Django é construído em Python. Portanto, precisamos de um ambiente de desenvolvimento Python robusto com todas as ferramentas necessárias para trabalhar com aplicativos Python. Já discutimos isso em um guia dedicado. Aqui, faremos uma breve demonstração.

Primeiro, abra um terminal e execute os seguintes comandos:

$ sudo apt update && sudo apt upgrade -y
$ sudo apt install python3 python-is-python3

1 2	$ sudo apt update && sudo apt upgrade -y $ sudo apt install python3 python-is-python3

Em seguida, instale o pip – o gerenciador de pacotes do Python:

$ sudo apt install python3-pip

1	$ sudo apt install python3-pip

Depois, instale alguns pacotes de desenvolvimento adicionais:

$ sudo apt install build-essential libssl-dev libffi-dev python3-dev

1	$ sudo apt install build-essential libssl-dev libffi-dev python3-dev

Para estabelecer um ambiente virtual, também precisamos do módulo Python venv :

$ sudo apt install python3-venv

1	$ sudo apt install python3-venv

Passo 2. Instalando o Servidor MySQL

O MySQL é um sistema de gerenciamento de banco de dados relacional popular. É de código aberto, estável e rico em recursos. Usaremos o MySQL como o servidor de banco de dados para o nosso aplicativo Django. Instale o MySQL usando o APT:

$ sudo apt install mysql-server

1	$ sudo apt install mysql-server

Em seguida, verifique a instalação:

$ systemctl status mysql

1	$ systemctl status mysql

É apenas uma configuração básica do MySQL com as opções padrão. Confira o guia mais detalhado sobre instalação e configuração do MySQL.

Passo 3. Configurando o Aplicativo Django

Agora estamos prontos para criar nosso aplicativo Django. Se você estiver interessado em uma demonstração mais detalhada do Django, consulte nosso tutorial, “Instalando o Framework Web Django no Ubuntu 20.04.”

Em seguida, crie um diretório dedicado para o aplicativo. O nome do diretório deve refletir o nome do projeto:

$ mkdir -pv <project_dir>

1	$ mkdir -pv <project_dir>

Dentro do diretório do projeto, crie um ambiente virtual Python usando o venv módulo:

$ python3 -m venv <virtual_env_name>

1	$ python3 -m venv <virtual_env_name>

Ative o ambiente virtual:

$ . sample_app_env/bin/activate

1	$ . sample_app_env/bin/activate

Instale o Django usando o pip:

$ pip install django

1	$ pip install django

Em seguida, crie um novo projeto Django usando o django-admin comando:

$ django-admin startproject sample_app

1	$ django-admin startproject sample_app

Passo 4. Configurando o Aplicativo Django

O aplicativo Django contém todas as configurações padrão. Para o nosso objetivo, precisamos fazer alguns ajustes.

Comece editando o arquivo de configuração settings.py:

$ nano sample_app/sample_app/sample_app/settings.py

1	$ nano sample_app/sample_app/sample_app/settings.py

Depois, altere o fuso horário:

$ TIME_ZONE = '<time_zone>'

1	$ TIME_ZONE = '<time_zone>'

Adicione as máquinas que têm permissão para acessar o servidor do aplicativo Django:

$ ALLOWED_HOSTS = ['<allowed_host_ip_or_domain_name >']

1	$ ALLOWED_HOSTS = ['<allowed_host_ip_or_domain_name >']

Depois disso, aplique as alterações:

$ python manage.py migrate

1	$ python manage.py migrate

Finalmente, crie um superusuário para o nosso aplicativo web Django:

$ python manage.py createsuperuser

1	$ python manage.py createsuperuser

Passo 5. Conectando o App Django ao MySQL

Para nos conectarmos ao MySQL, precisamos de uma biblioteca de conector Python adicional que seja compatível com o Django. Usaremos o mysqlclient.

Primeiro, certifique-se de que temos os pacotes necessários instalados:

$ sudo apt install python3-dev libmysqlclient-dev default-libmysqlclient-dev

1	$ sudo apt install python3-dev libmysqlclient-dev default-libmysqlclient-dev

Em seguida, instale o mysqlclient:

$ pip install mysqlclient

1	$ pip install mysqlclient

Criando um Banco de Dados Dedicado

Para o nosso app, precisamos criar um banco de dados dedicado e um usuário de banco de dados. Inicie o shell do MySQL como root:

$ sudo mysql -u root

1	$ sudo mysql -u root

Crie um banco de dados dedicado para o nosso app Django:

$ CREATE DATABASE <dedicated_database>;

1	$ CREATE DATABASE <dedicated_database>;

Depois, crie um usuário de banco de dados dedicado para o app Django:

$ CREATE USER '<username>'@'%' IDENTIFIED WITH mysql_native_password BY '<user_password>';

1	$ CREATE USER '<username>'@'%' IDENTIFIED WITH mysql_native_password BY '<user_password>';

Finalmente, conceda ao usuário dedicado permissão total no banco de dados dedicado:

$ GRANT ALL ON <database>.* TO '<username'@'%';

1	$ GRANT ALL ON <database>.* TO '<username'@'%';

Alterando a Configuração do Django para usar o MySQL

Agora, precisamos ajustar algumas configurações do Django para que ele possa usar o MySQL como servidor de banco de dados. Abra o settings.py em um editor de texto:

$ nano settings.py

1	$ nano settings.py

Role para baixo até a seção DATABASES e cole o seguinte código:

DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'OPTIONS': {
'read_default_file': '/etc/mysql/my.cnf',
},
}
}

DATABASES = {

'default': {

'ENGINE': 'django.db.backends.mysql',

'OPTIONS': {

'read_default_file': '/etc/mysql/my.cnf',

}

Em seguida, edite o arquivo de configuração do MySQL para que ele contenha as credenciais de banco de dados necessárias:

$ sudo nano /etc/mysql/my.cnf

1	$ sudo nano /etc/mysql/my.cnf

Adicione o seguinte bloco no final do arquivo:

[client]
database = <dedicated_database>
user = <dedicated_user>
password = <user_password>
default-character-set = utf8

[client]

database = <dedicated_database>

user = <dedicated_user>

password = <user_password>

default-character-set = utf8

Reinicie o MySQL para que as alterações entrem em vigor:

$ sudo systemctl daemon-reload
$ sudo systemctl restart mysql

1 2	$ sudo systemctl daemon-reload $ sudo systemctl restart mysql

Passo 6. Criando um Model do Django

Agora estamos prontos para criar um novo model dentro do nosso projeto Django. Ative o ambiente virtual:

$ cd sample_app/
$ . sample_app_env/bin/activate
$ cd sample_app/

$ cd sample_app/

$ . sample_app_env/bin/activate

$ cd sample_app/

Neste local, diga ao Django para criar um novo app:

$ python manage.py startapp <new_app>

1	$ python manage.py startapp <new_app>

Após a criação, a árvore de arquivos deve se parecer com isto. Aqui, o arquivo models.py conterá os códigos para o nosso model personalizado do Django:

Verifique o conteúdo atual do arquivo:

$ cat models.py

1	$ cat models.py

Para demonstração, vamos criar um model para posts de blog chamado Post. Ele conterá os seguintes campos:

title: Título do post do blog.
slug: Armazena e gera URLs válidas para páginas web.
content: O texto do post do blog.
created_on: Data de criação do post.
author: O usuário que criou o post.

Abra o arquivo models.py em um editor de texto:

$ nano models.py

1	$ nano models.py

Vamos importar algumas APIs necessárias para o nosso model. Por padrão, ele importa a API de models. Também precisaremos da API slugify para gerar slugs, User para autenticação, e reverse para uma criação de URL melhor e mais flexível:

from django.db import models
from django.template.defaultfilters import slugify
from django.contrib.auth.models import User
from django.urls import reverse

from django.db import models

from django.template.defaultfilters import slugify

from django.contrib.auth.models import User

from django.urls import reverse

Em seguida, adicione o método de classe chamado Post. Ele conterá os campos de banco de dados necessários como title, slug, content, created_on, e author:

class Post(models.Model):
   title = models.CharField(max_length=255)
   slug = models.SlugField(unique=True, max_length=255)
   content = models.TextField()
   created_on = models.DateTimeField(auto_now_add=True)
   author = models.TextField()

class Post(models.Model):

title = models.CharField(max_length=255)

slug = models.SlugField(unique=True, max_length=255)

content = models.TextField()

created_on = models.DateTimeField(auto_now_add=True)

author = models.TextField()

Precisamos da funcionalidade para geração de URL e salvamento do post. É importante, pois gera links exclusivos correspondentes a posts exclusivos:

def get_absolute_url(self):
   return reverse('blog_post_detail', args=[self.slug])

def save(self, *args, **kwargs):
   if not self.slug:
      self.slug = slugify(self.title)
      super(Post, self).save(*args, **kwargs)

def get_absolute_url(self):

return reverse('blog_post_detail', args=[self.slug])

def save(self, *args, **kwargs):

if not self.slug:

self.slug = slugify(self.title)

super(Post, self).save(*args, **kwargs)

A próxima seção informará ao modelo sobre a ordenação do post e sua exibição na página web. Codificaremos a lógica usando uma classe interna, Meta. Ela conterá lógica de modelo adicional que não diz respeito à definição de campos do banco de dados:

class Meta:
   ordering = ['created_on']

def __unicode__(self):
   return self.title

class Meta:

ordering = ['created_on']

def __unicode__(self):

return self.title

Finalmente, teremos o recurso do modelo Comment neste arquivo. Isso requer a adição de outra classe Comment usando models.Model como sua assinatura. Ele conterá os seguintes campos de banco de dados:

name: Nome do autor do comentário.
email: Endereço de e-mail do autor do comentário.
text: Conteúdo do próprio comentário.
post: O post no qual o comentário foi feito.
created_on: Momento da criação do comentário.

O código será parecido com isto:

class Comment(models.Model): 
   name = models.CharField(max_length=42) 
   email = models.EmailField(max_length=75) 
   website = models.URLField(max_length=200, null=True, blank=True) 
   content = models.TextField() 
   post = models.ForeignKey(Post, on_delete=models.CASCADE) 
   created_on = models.DateTimeField(auto_now_add=True)

class Comment(models.Model):

name = models.CharField(max_length=42)

email = models.EmailField(max_length=75)

website = models.URLField(max_length=200, null=True, blank=True)

content = models.TextField()

post = models.ForeignKey(Post, on_delete=models.CASCADE)

created_on = models.DateTimeField(auto_now_add=True)

Neste ponto, nosso arquivo models.py ficará assim:

Finalmente, salve o arquivo e feche o editor.

Passo 7. Atualizando as Configurações do Django

O modelo está criado. No entanto, precisamos ajustar alguns arquivos de configuração para colocar o modelo em ação. Dentro de settings.py, precisamos adicionar nosso modelo sob INSTALLED_APPS.

Abra settings.py em um editor de texto:

$ nano settings.py

1	$ nano settings.py

Registre o novo módulo sob a seção INSTALLED_APPS:

Salve o arquivo e feche o editor.

Passo 8. Migrando Alterações

Agora que adicionamos todos os modelos desejados, o próximo passo é aplicar essas alterações. O Django aplicará esses esquemas ao nosso banco de dados MySQL.

O seguinte comando gerará todos os arquivos de migração necessários. A saída mostrará os locais de todos esses arquivos dentro do diretório do projeto:

$ python manage.py makemigrations

1	$ python manage.py makemigrations

O seguinte comando listará todas as migrações existentes:

$ python manage.py showmigrations

1	$ python manage.py showmigrations

Observe que todas as migrações estão marcadas, exceto por 0001_initial que foi criada como parte dos modelos Post e Comment.

O seguinte comando mostrará qual consulta SQL o Django executará para realizar as migrações:

$ python manage.py sqlmigrate random_app 0001_initial

1	$ python manage.py sqlmigrate random_app 0001_initial

Tudo o que precisamos agora é aplicar as migrações. Essas migrações gravarão as alterações no banco de dados:

$ python manage.py migrate

1	$ python manage.py migrate

Passo 9. Verificando as Alterações

Para verificar as alterações, vamos dar uma olhada no nosso banco de dados MySQL. Inicie o shell do MySQL como o usuário do Django:

$ mysql sample_app_data -u sample_app_user

1	$ mysql sample_app_data -u sample_app_user

Em seguida, altere o banco de dados ativo atual para o banco de dados do aplicativo Django:

$ USE <django_dedicated_database>;

1	$ USE <django_dedicated_database>;

Liste todas as tabelas do banco de dados:

$ SHOW TABLES;

1	$ SHOW TABLES;

Por fim, para ver o conteúdo de qualquer uma das tabelas, use a DESCRIBE consulta:

$ DESCRIBE random_app_comment;
$ DESCRIBE random_app_post;

1 2	$ DESCRIBE random_app_comment; $ DESCRIBE random_app_post;

Limitações do Django com o MySQL

Ao usar o MySQL como servidor de banco de dados para seu aplicativo Django, há algumas coisas que você deve ter em mente:

Não há muito suporte para transações em processos de alteração de esquema. Ou seja, se uma migração falhar, será necessário desfazer manualmente todas as alterações antes de tentar outra migração. Não há como reverter para um ponto anterior onde a migração com falha não ocorreu.
Para a maioria dos processos de alteração de esquema, o MySQL reescreve completamente as tabelas. Em certas situações, isso pode ser muito demorado. Na pior das hipóteses, a complexidade de tempo será proporcional ao número de linhas a serem adicionadas ou colunas a serem removidas. De acordo com a documentação oficial do Django, isso pode levar um minuto por milhão de linhas.
O MySQL impõe um limite de caracteres para o comprimento dos nomes de colunas, tabelas e índices. Também há um limite no tamanho total de todas as colunas e coberturas de índice. O Django pode ir além desse limite. Alguns backends que não sejam o MySQL conseguem lidar com o limite mais alto do Django.

É por isso que é altamente recomendável avaliar suas opções e escolher a mais adequada.

Considerações Finais

Este guia demonstra com sucesso como adicionar módulos a um aplicativo Django existente. Usamos o MySQL como backend para o aplicativo. Ele também apresenta alguns conceitos-chave do Django, como modelos, como funciona a migração e como o Django traduz modelos em tabelas de banco de dados MySQL.

Boa computação!

Hark Labs

Autor · CloudSigma

Preslav Dobrev é um designer criativo na CloudSigma, focado na construção de uma identidade empresarial consistente por meio de canais de marketing tradicionais e inovadores. Ele é hábil em combinar a visão artística com o marketing estratégico para criar narrativas de marca impactantes.