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á um ambiente de desenvolvimento para trabalhar na sua aplicação web de 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 não-root habilitado para sudo 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 o 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 concentra-se 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, bem como um perfil de usuário MySQL que o Django possa usar para se conectar ao banco de dados.

Para configurar isso, conecte-se ao seu banco de dados MySQL como o usuário root 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, supondo 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 nesses, 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, usando 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 MySQL separada que o Django usará para operar o novo banco de dados. Criar bancos de dados e contas específicas pode apoiá-lo do ponto de vista de gerenciamento e segurança. Vamos usar o nome djangouser neste guia. Você pode usar qualquer nome que desejar, 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, cada um feito especificamente para o Django. Limpe os privilégios para que a instância atual do MySQL saiba sobre as mudanças recentes que você fez:

FLUSH PRIVILEGES;

Com isso concluído, 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 só 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 está definido como a codificação padrão. Esta é uma maneira comum de codificar dados Unicode no MySQL. Quando você tiver certeza de que seus detalhes estão corretos, salve e feche o arquivo. Se você usou o nano para editar o arquivo, você pode fazê-lo pressionando CTRL + O para salvar o arquivo e depois CTRL + X para fechar o editor.

Assim 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ê vai preparar o terreno 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 de algo significativo para a aplicação que você está construindo. Como exemplo, vamos chamar o nosso de my_blog_app:

mkdir my_blog_app

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

cd my_blog_app

Em seguida, entre no ambiente de programação que você gostaria de usar para trabalhar com Django. Você pode usar um 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

Assim que for criado, você pode ativá-lo:

. env/bin/activate

Agora instale o Django neste ambiente se você 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 continuar para o próximo passo.

Passo 4 — Instalando o Conector de Banco de Dados MySQL

Para usar o MySQL com o 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 bibliotecas MySQL necessários:

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. Instalar programas Python a partir de pacotes wheel é geralmente mais rápido e mais eficiente em recursos do que construir pacotes a partir do seu 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

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

Output
...
Successfully installed mysqlclient-2.1.1

Agora você instalou com sucesso o cliente MySQL usando a biblioteca de conector mysqlclient do PyPi.

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

Ao executar o django-admin anteriormente, ele criou 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 para o arquivo com 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, usaremos 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 seja definida para seu fuso horário atual. Usaremos o fuso horário de Nova York neste exemplo:

...

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'America/New_York'

USE_I18N = True
...

Mantenha o arquivo aberto porque a seguir, você precisa adicionar um caminho para seus arquivos estáticos. Os arquivos que são servidos pela sua aplicação web Django são referidos como arquivos estáticos. Isso pode incluir quaisquer arquivos necessários para renderizar a página da 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, estará perto do topo do arquivo settings.py. Adicione o endereço IP do seu servidor, cercado por aspas simples, entre os colchetes:

...
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 Django. Para fazer isso, você precisa importar o módulo os que funcionará em seu sistema operacional respectivo. 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 adequado tenha sido configurado. Você também adicionou o caminho para seus arquivos estáticos, definiu seu endereço IP como 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. Por padrão, ele terá a seguinte aparência:

…

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

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

...

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

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

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

• OPTIONS
• NAME, USER, PASSWORD, HOST, PORT
• Arquivos de opções do MySQL

Ao apontar o Django para o seu arquivo de opções 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ções se você apontasse para ele fora da configuração OPTIONS.

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

Em seguida, verifique se há 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 utilizar na interface de administração 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.

Após concluir estas informações, você pode prosseguir ajustando as configurações do seu firewall para permitir testes.

Passo 6 — Ajustando as Configurações do Firewall

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

sudo ufw allow 8000

Verifique o status para garantir que essas configurações de permissão 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)

Suas configurações de firewall estão agora devidamente ajustadas para permitir o teste da sua 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 o 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/

A partir daí, 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-de-ip-do-servidor:8000/, para visualizar sua aplicação web e verificar se 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 seu aplicativo, pressione CTRL + C para interromper o comando runserver. Isso o retornará ao seu ambiente de programação.

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

deactivate

Desativar 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 do seu aplicativo, como TIME_ZONE, ALLOWED_HOSTS, import os e credenciais de 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 e ajustes básicos estão completos, você pode começar a desenvolver modelos e aplicar migrações em sua aplicação Django.