Como criar um aplicativo Django e conectá-lo a um banco de dados

Introdução

O Django é um framework web gratuito e de código aberto escrito em Python. Esta ferramenta permite escalabilidade, reutilização e desenvolvimento rápido.

Neste tutorial, você aprenderá como configurar a base inicial para um site de blog com conexões a um banco de dados MySQL. Isso envolverá a criação da estrutura esquelética da aplicação web do blog usando django-admin, criando o banco de dados MySQL e conectando a aplicação web ao banco de dados.

O Django fornecerá a você um ambiente de desenvolvimento para trabalhar em sua aplicação web do blog, mas você precisará seguir mais etapas antes de tornar seu blog disponível na internet.

Pré-requisitos

Para seguir este tutorial, você precisará de:

• Um servidor Ubuntu 22.04 com um usuário sudo não-root habilitado e um firewall. Siga nosso guia de configuração inicial do servidor Ubuntu 22.04 para configurar isso.
• O MySQL está instalado para servir como banco de dados. Você pode configurar isso seguindo nosso tutorial sobre Como Instalar o MySQL no Ubuntu 22.04.
• A Python environment set up. For this, follow our tutorial on How To Install Python 3 and Set Up a Programming Environment on Ubuntu 22.04
  .

Assim que tudo estiver instalado e configurado, você pode prosseguir para o primeiro passo.

Passo 1 — Criando o Banco de Dados

O Django suporta diversos sistemas populares de gerenciamento de banco de dados, mas este guia foca em conectar o Django a um banco de dados MySQL. Para fazer isso, você precisa criar um banco de dados em sua instância MySQL, assim como um perfil de usuário MySQL que o Django possa utilizar para se conectar ao banco de dados.

Para configurar isso, conecte-se ao seu banco de dados MySQL como o usuário root do MySQL com o seguinte comando:

sudo mysql

Você saberá que está no servidor MySQL quando o prompt mudar:

Inspeccione os bancos de dados atuais com o seguinte comando:

SHOW DATABASES;

Sua saída será semelhante à seguinte, presumindo que você ainda não tenha criado nenhum banco de dados:

Output
+--------------------+
| Database       	|
+--------------------+
| information_schema |
| mysql         	|
| performance_schema |
| sys            	|
+--------------------+
4 rows in set (0.00 sec)

Por padrão, você terá 4 bancos de dados já criados: information_schema, MySQL, performance_schema e sys. Você não precisará mexer neles, pois contêm informações importantes para o próprio servidor MySQL.

Em vez disso, crie o banco de dados inicial que conterá os dados para o seu blog.

Para criar um banco de dados no MySQL, execute o seguinte comando, utilizando um nome significativo para o seu banco de dados:

CREATE DATABASE blog_data;

Após a criação bem-sucedida do banco de dados, a saída será a seguinte:

Output
Query OK, 1 row affected (0.00 sec)

Verifique se o banco de dados agora está listado como um dos bancos de dados disponíveis:

SHOW DATABASES;

O banco de dados blog_data deve agora estar listado entre os bancos de dados incluídos na saída:

Output
+--------------------+
| Database       	|
+--------------------+
| information_schema |
| blog_data      	|
| mysql             	|
| performance_schema |
| sys            	|
+--------------------+
5 rows in set (0.00 sec)

Em seguida, crie uma conta de usuário separada no MySQL que o Django utilizará para operar o novo banco de dados. A criação de bancos de dados e contas específicas pode apoiá-lo do ponto de vista de gerenciamento e segurança. Neste guia, usaremos o nome djangouser. Você pode usar o nome que preferir, mas pode ser útil escolher um nome descritivo.

Você vai criar esta conta, definir uma senha e conceder acesso ao banco de dados que você criou. Primeiro, crie o usuário e defina sua senha digitando o seguinte comando. Lembre-se de escolher uma senha forte para o seu banco de dados, substituindo password neste exemplo:

CREATE USER 'djangouser'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';

Informe ao banco de dados que djangouser deve ter acesso completo ao banco de dados que você configurou:

GRANT ALL ON blog_data.* TO 'djangouser'@'localhost';

Agora você tem um banco de dados e uma conta de usuário, ambos feitos especificamente para o Django. Limpe os privilégios para que a instância atual do MySQL saiba sobre as alterações recentes que você fez:

FLUSH PRIVILEGES;

Com isso completo, você pode sair do servidor MySQL escrevendo EXIT; ou pressionando CTRL + D.

Passo 2 — Criando um Arquivo de Opções do MySQL

Em vez de especificar os detalhes da sua conexão MySQL no arquivo de configuração do Django, você pode armazená-los em um arquivo de opções. Muitos programas MySQL podem ler arquivos de opções — também conhecidos como arquivos de configuração — para informações como opções de inicialização ou detalhes de conexão. Isso pode ser conveniente, pois você só precisa armazenar suas credenciais de login do banco de dados em um único lugar.

Abra o arquivo de configuração my.cnf com o seu editor de texto preferido para atualizar suas credenciais do MySQL. Aqui vamos usar o nano:

sudo nano /etc/mysql/my.cnf

Adicione as seguintes linhas e inclua suas informações relevantes:

…

[client]
database = blog_data
user = djangouser
password = your_actual_password
default-character-set = utf8

Observe que utf8 é definido como a codificação padrão. Esta é uma maneira comum de codificar dados unicode no MySQL. Quando você estiver certo de que seus detalhes estão corretos, salve e feche o arquivo. Se você usou o nano para editar o arquivo, pode fazer isso pressionando CTRL + O para salvar o arquivo e depois CTRL + X para fechar o editor.

Depois que o arquivo for editado, reinicie o MySQL para que as alterações tenham efeito:

sudo systemctl daemon-reload
sudo systemctl restart mysql

Observe que reiniciar o MySQL leva alguns segundos, então por favor tenha paciência.

Passo 3 — Criando o Esqueleto Inicial do Projeto Django

Neste passo, você irá estabelecer as bases para sua aplicação gerando o esqueleto do projeto usando o comando django-admin.

Navegue até o diretório onde você gostaria de construir sua aplicação de blog. Dentro desse diretório, crie um diretório específico para construir a aplicação. Chame o diretório com algo significativo para a aplicação que você está construindo. Como exemplo, vamos chamá-lo de my_blog_app:

mkdir my_blog_app

Agora, navegue até o diretório recém-criado:

cd my_blog_app

Em seguida, mova-se para o ambiente de programação que você gostaria de usar para trabalhar com o Django. Você pode usar um ambiente existente ou criar um novo. O seguinte comando cria um novo ambiente chamado env, mas você deve usar um nome que faça sentido para você:

python3 -m venv env

Uma vez criado, você pode ativá-lo:

. env/bin/activate

Agora, instale o Django neste ambiente se ainda não o fez:

pip install django

Enquanto estiver no diretório my_blog_app, gere um projeto executando o seguinte comando:

django-admin startproject blog

Verifique se funcionou navegando até o diretório blog/:

cd blog

Em seguida, execute ls para verificar se os arquivos e diretórios necessários foram criados dentro da pasta do projeto:

ls

A saída listará o diretório blog e um arquivo manage.py:

Output
blog manage.py

Agora que você criou um diretório de projeto contendo o início inicial da sua aplicação de blog, você pode prosseguir para o próximo passo.

Passo 4 — Instalando o Conector de Banco de Dados MySQL

Para usar o MySQL com seu projeto, você precisa de uma biblioteca de conector de banco de dados Python 3 compatível com o Django. Este passo descreve como instalar um desses conectores de banco de dados, mysqlclient, que é uma versão derivada de MySQLdb.

Primeiro, instale os cabeçalhos de desenvolvimento e as bibliotecas necessárias do MySQL:

sudo apt install libmysqlclient-dev default-libmysqlclient-dev

Em seguida, use pip para instalar o pacote wheel. Wheel é um formato de empacotamento usado em Python para instalar módulos do Índice de Pacotes Python. A instalação de programas Python a partir de pacotes wheel geralmente é mais rápida e mais eficiente em recursos do que a construção de pacotes a partir do código-fonte. Para instalar e trabalhar com programas empacotados como wheels, primeiro você precisa garantir que o pacote wheel esteja instalado:

pip install wheel

Em seguida, prossiga com a instalação do mysqlclient:

pip install mysqlclient

Seu resultado será semelhante ao seguinte, verificando se o cliente foi instalado corretamente:

Output
...
Successfully installed mysqlclient-2.1.1

Você agora instalou com sucesso o cliente MySQL usando a biblioteca de conector PyPi mysqlclient.

Passo 5 — Edição das Configurações

Ao executar anteriormente django-admin, foi criado um arquivo de configuração para o Django chamado settings.py. Você precisa alterar algumas das configurações padrão neste arquivo para que tudo funcione corretamente.

Para editar o arquivo, abra o caminho do arquivo com o seu editor de texto preferido:

nano ~/my_blog_app/blog/blog/settings.py

Para que seu blog tenha o horário correto associado à sua área, você pode editar o arquivo settings.py para que ele utilize seu fuso horário atual. Você pode usar esta lista de fusos horários como referência. Para nosso exemplo, vamos usar o horário America/New_York.

Dentro do arquivo, navegue até o campo TIME_ZONE próximo à seção inferior do arquivo:

...

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'UTC'

USE_I18N = True

USE_L10N = True

USE_TZ = True
...

Modifique a linha TIME_ZONE, para que esteja configurada para o seu fuso horário atual. Neste exemplo, vamos usar o fuso horário de Nova York:

...

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'America/New_York'

USE_I18N = True
...

Mantenha o arquivo aberto, porque em seguida, você precisa adicionar um caminho para seus arquivos estáticos. Os arquivos que são servidos a partir da sua aplicação web Django são referidos como arquivos estáticos. Isso pode incluir quaisquer arquivos necessários para renderizar a página web completa, incluindo JavaScript, CSS e imagens.

Vá até o final do arquivo settings.py e adicione STATIC_ROOT:

…

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

Agora que você adicionou o fuso horário e o caminho para os arquivos estáticos, adicione seu IP à lista de hosts permitidos. Navegue até a linha do arquivo settings.py onde está escrito ALLOWED_HOSTS, ela estará perto do topo do arquivo settings.py. Adicione o endereço IP do seu servidor, cercado por aspas simples, entre os colchetes angulares:

...
ALLOWED_HOSTS = ['your_server_IP_address']
...

Em seguida, adicione o módulo OS do Python que fornece várias funcionalidades para diretórios. Sem este módulo, você receberá um erro ao configurar o usuário administrativo para começar a usar a interface do Django. Para fazer isso, você precisa importar o módulo os que funcionará no seu respectivo sistema operacional. Adicione a linha import os acima da linha from pathlib import Path:

...
import os
from pathlib import Path
...

Até agora, você editou seu arquivo settings.py para que o fuso horário correto tenha sido configurado. Você também adicionou o caminho para seus arquivos estáticos, configurou seu endereço IP para ser um HOST PERMITIDO para sua aplicação e importou o módulo OS do Python para ajudar a configurar seu usuário administrativo mais tarde.

O último trecho a ser adicionado ao seu arquivo são as credenciais de conexão do banco de dados para conectar sua aplicação de blog Django ao MySQL. Para isso, encontre o dicionário DATABASES dentro do arquivo. Ele terá o seguinte aspecto por padrão:

…

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

Substitua as opções ENGINE e NAME do dicionário DATABASES com as seguintes linhas:

...

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

A linha 'ENGINE': 'django.db.backends.mysql' diz ao Django para usar seu backend de banco de dados MySQL integrado. A opção read_default_file aponta para /etc/mysql/my.cnf, o arquivo de opções do MySQL que você editou anteriormente. Isso diz ao Django onde ele pode encontrar os detalhes de conexão relevantes para se conectar ao banco de dados MySQL que você criou na Etapa 1.

Observe que o Django lê as configurações de conexão com o banco de dados na seguinte ordem:

• OPTIONS
• NAME, USER, PASSWORD, HOST, PORT
• Arquivos de opção do MySQL

Ao apontar o Django para o arquivo de opção do MySQL dentro da configuração OPTIONS como neste exemplo, ele terá precedência sobre qualquer configuração NAME, que de outra forma substituiria o arquivo de opção se você apontasse para ele fora da configuração OPTIONS.

Neste ponto, você pode salvar e fechar o arquivo.

Em seguida, verifique as alterações de migração executando o seguinte:

python manage.py makemigrations

Depois, execute migrate para garantir que as alterações sejam aplicadas:

python manage.py migrate

Agora que suas alterações foram migradas, você pode criar um usuário administrativo para usar na interface administrativa do Django. Faça isso com o comando createsuperuser:

python manage.py createsuperuser

Você será solicitado a fornecer um nome de usuário, um endereço de e-mail e uma senha para o seu usuário.

Depois de fornecer essas informações, você pode prosseguir ajustando as configurações do firewall para permitir testes.

Passo 6 — Ajustando Configurações do Firewall

Antes de testar sua aplicação web Django, você deve garantir que as configurações do seu firewall tenham sido ajustadas. Comece alterando as configurações do ufw para permitir o acesso à porta 8000:

sudo ufw allow 8000

Verifique o status para garantir que essas permissões tenham sido atualizadas com sucesso:

sudo ufw status

Output
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
8000                       ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
8000 (v6)                  ALLOW       Anywhere (v6)

Agora suas configurações de firewall estão corretamente ajustadas para permitir o teste da conexão no próximo passo.

Passo 7 — Testando a Conexão MySQL com a Aplicação

Agora você pode verificar se as configurações no Django detectam corretamente seu servidor MySQL. Você pode fazer isso executando o servidor. Se falhar, significa que a conexão não está funcionando corretamente. Caso contrário, a conexão é válida.

Primeiro navegue até o seguinte diretório:

cd ~/my_blog_app/blog/

Em seguida, execute o seguinte comando:

python manage.py runserver your-server-ip:8000

Você receberá uma saída semelhante à seguinte:

Output
Performing system checks...

System check identified no issues (0 silenced).
July 19, 2022 - 13:26:08
Django version 4.0.6, using settings 'blog.settings'
Starting development server at http://your-server-ip:8000/
Quit the server with CONTROL-C.

Siga as instruções da saída e acesse o link sugerido, http://seu-endereço-ip-do-servidor:8000/, para visualizar sua aplicação web e verificar se ela está funcionando corretamente.

Se sua página aparecer semelhante à captura de tela acima, sua aplicação Django está funcionando conforme o esperado.

Quando terminar de testar sua aplicação, pressione CTRL + C para interromper o comando runserver. Isso o levará de volta ao seu ambiente de programação.

Quando estiver pronto para sair do seu ambiente Python, você pode executar o comando deactivate:

deactivate

A desativação do seu ambiente de programação o trará de volta ao prompt de comando do terminal.

Conclusão

Neste tutorial, você criou a base inicial do seu blog Django. Você instalou, configurou e conectou o MySQL ao backend do Django. Você também adicionou algumas informações importantes ao arquivo settings.py da sua aplicação, como TIME_ZONE, ALLOWED_HOSTS, import os e credenciais do banco de dados para conectar sua aplicação Django ao MySQL. Você também ajustou as configurações do firewall para garantir que os testes ocorram sem problemas.

Agora que essas configurações básicas foram concluídas, você pode começar a desenvolver modelos e aplicar migrações em sua aplicação Django.