Python

Principais comandos do Django CLI

Quando estamos iniciando os estudos com o Django, é bem comum esquecermos os principais comandos para gerenciar nossa aplicação (executar o servidor de desenvolvimento, criar um projeto, criar uma aplicação, criar migrações, etc). Pensando nisso, neste artigo veremos quais são os comandos responsáveis por cada uma das principais funcionalidades do CLI do Django.

Criar Projeto

Para criar um projeto no Django, utilizamos o seguinte comando no terminal:

django-admin startproject nome_do_projeto

Este comando irá criar um projeto Django vazio, com a estrutura de arquivos e diretórios padrão do framework.

Criar Aplicação

Após criar um projeto, precisamos criar uma (ou mais) aplicações para o projeto. Para isso, utilizamos o seguinte comando:

python manage.py startapp nome_da_app

Lembrando que este comando deverá ser executado no mesmo diretório em que se encontra o arquivo manage.py do projeto, ou seja, dentro do diretório padrão do projeto que estamos criando.

Criar Migrações

Após determinar quais serão as entidades que utilizaremos em nosso projeto, precisamos criar as tabelas que representam estas entidades no banco de dados. Para isso, utilizamos o seguinte comando:

python mananage.py makemigrations

O comando acima irá obter a estrutura das classes definidas no arquivo models.py e criará os arquivos de migração de cada classe.

Executar Migrações

Após criar os arquivos que definem a estrutura de cada entidade no banco de dados, precisamos executar estas migrações. Para isso, utilizamos o seguinte comando:

python manage.py migrate

Com isso, todas as classes definidas no arquivo models.py serão transformadas em tabelas no banco de dados.

Executar Servidor de Desenvolvimento

Para executar o servidor de desenvolvimento do Django e, assim, testar nosso projeto, utilizamos o seguinte comando:

python manage.py runserver

Este comando irá executar o servidor do Django no endereço http://localhost:8000, que poderá ser utilizado para executar o projeto, como podemos ver na imagem abaixo:

Limpar Banco de Dados

Quando estamos desenvolvendo nossa aplicação, é comum que queiramos limpar todos os dados do banco de dados para realizar novos testes. Para realizar este procedimento, utilizamos o seguinte comando:

python manage.py flush

Este comando irá limpar todos os dados salvos no banco de dados do projeto, mantendo sua estrutura.

Abrir Shell do Banco de Dados Configurado

Se quisermos manipular o banco de dados diretamente do shell do SGBD, podemos utilizar o seguinte comando para criar uma conexão com o mesmo:

python manage.py dbshell

Este comando irá iniciar o shell do banco de dados ao qual o projeto django está configurado, como podemos ver abaixo:

Mapear BD existente para o projeto Django

Caso você possua um banco de dados já existente e queira mapeá-lo para seu projeto Django, o seguinte comando resolve esta necessidade:

python manage.py inspectdb > nome_da_app.models.py

Este comando irá mapear o banco de dados já existente no arquivo models.py da sua aplicação, conforme vimos neste artigo.

Utilizando o Redis como Cache em um projeto Django

A performance de um projeto é de vital importância para o sucesso de uma aplicação. Dificilmente um site que demore um tempo considerável para responder uma solicitação de um usuário, não sucumbirá ao fracasso. Pensando nisso, há diversas maneiras de tentar melhorar o desempenho de uma aplicação, dentre elas, utilizar o Cache para armazenar dados que são frequentemente utilizados, é uma ótima alternativa.

Como funciona o Cache

O Cache é um recurso que possibilita o acesso às informações de forma mais rápida. Basicamente, é uma forma de armazenar determinadas informações que são consumidas com mais frequência para que elas sejam disponibilizadas no menor tempo possível.

O funcionamento do Cache pode ser entendido da seguinte forma:

  1. A aplicação verifica se os dados solicitados estão em cache;

  2. Se sim, o cache devolve para a aplicação, que os exibe;

  3. Se não, os dados são obtidos do banco de dados, salvos no cache e retornados para aplicação;

  4. Da próxima vez, o cache já possuirá os dados armazenados e, assim, retornados em um tempo menor.

Instalando o Redis

A instalação do Redis varia conforme o sistema operacional utilizado, abaixo veremos como instalar o Redis no Windows, Linux e macOS.

Windows

A instalação do Redis no Windows é bem simples. Primeiro, precisamos baixar o arquivo .zip do diretório oficial do Redis ():

Após realizar o download, descompactamos e executamos o arquivo redis-server, localizado no diretório 32bits ou 64bits, dependendo do sistema operacional.

Linux

A instalação do Redis no Linux também é bem simples. Primeiro, abrimos o terminal e digitamos os seguintes comandos:

sudo apt-get install redis-server
sudo systemctl enable redis-server.service

Com isso, o Redis será instalado e executado no Linux.

macOS

Para instalar o Redis no macOS também é super simples. Com o Homebrew instalado, podemos abrir o terminal e digitar o seguinte comando:

brew install redis
ln -sfv /usr/local/opt/redis/*.plist ~/Library/LaunchAgents

Com isso, o Redis será instalado e configurado para iniciar sempre que ligarmos o computador.

Configurando o Redis no Django

Com o Redis instalado, precisamos configurar a comunicação entre as tecnologias (Django e Redis). Para isso, o primeiro passo é instalar o pacote django-redis na virtualenv do projeto seguindo os seguintes passos:

No PyCharm, vamos até a aba “Project Interpreter” e clicamos no “+” localizado no canto inferior esquerdo:

Após isso, buscamos pelo pacote “django-redis” e o instalamos em nossa virtualenv:


Com isso, o Redis já está pronto para ser utilizado em nosso projeto Django 🙂

Utilizando o Redis como Cache

Após instalar e configurar o Redis em nosso projeto Django, precisamos configurar o projeto para utilizar o Redis como Cache das informações. Para isso, no arquivo settings.py, adicionamos a seguinte configuração:

CACHES = {
    'default': {
        'BACKEND': 'django_redis.cache.RedisCache',
        'LOCATION': 'redis://127.0.0.1:6379/1',
        'OPTIONS': {
            'CLIENT_CLASS': 'django_redis.client.DefaultClient'
        },
        'KEY_PREFIX': 'django_orm'
    }
}

A configuração acima permitirá que o Django se comunique com o servidor do Redis que está sendo executado localmente.

Agora precisamos indicar quais páginas utilizarão o Cache para armazenar suas informações. Para isso, no nosso arquivo de views do projeto, adicionamos a anotação @cache_page(tempo_de_vida_cache) nos métodos que queremos utilizar o cache (normalmente, nas páginas com mais acessos):

@cache_page(60)
def listar_clientes(request):
    clientes = cliente_service.listar_clientes()
    return render(request, 'clientes/lista_clientes.html', {'clientes': clientes})

Com isso, sempre que um usuário solicitar o método para listagem de todos os clientes, o Django, primeiro, verificará se estas informações existem no Redis. Se sim, é de lá que as informações serão listadas, caso contrário, o Django fará uma consulta no banco de dados, obterá a lista de clientes, inserirá no cache e retornará ao usuário.

Comparando performances

A quantidade de requisições por segundo pode variar um pouco, mas é bem nítido o ganho de performance do uso do Redis como Cache em nossa aplicação. Na imagem abaixo podemos ver a diferença entre a quantidade de requisições utilizando o Redis e o uso do banco de dados:

Conclusão

O uso do Cache é uma ótima alternativa quando precisamos garantir o retorno dos dados em um tempo menor em páginas que são frequentemente acessadas. Vale lembrar que não devemos (e nem precisamos) usá-lo em todas as páginas, apenas nas mais acessadas.

Mapeando banco de dados existente com Django

O Django é um ótimo framework para iniciar um projeto completamente do zero, mas nem sempre este é nosso caso. Imagine que uma empresa pretende migrar uma aplicação legada (antiga) com 100 tabelas em seu banco de dados e escolhe o Django como sua nova tecnologia… Como faríamos para mapear todo o banco de dados (tabelas e relações) para nosso projeto? Parece algo cansativo e complicado, certo!? Bom, com o Django, isso pode ser mais fácil do que parece…

Banco de Dados

Para nosso exemplo, iremos utilizar um banco de dados com uma estrutura que armazena a lista de empregados de uma empresa e suas relações. Não vamos nos preocupar com a estrutura do banco de dados em si, o importante aqui é entender que teremos 6 tabelas com os seguintes campos:

Para criar o banco de dados acima em seu MySQL, precisamos baixar toda a sua estrutura no repositório encontrado no seguinte link:

Depois disso, vamos baixar seu código-fonte e salvar no Desktop do nosso computador. Depois de descompactado, utilizamos o terminal para incorporar o banco de dados teste para o MySQL presente em nossa máquina. Para isso, no terminal (ou CMD), utilizamos o seguinte comando:

mysql -u root -p < employees.sql

Lembrando que o “root” é o nome do usuário do banco de dados. Caso o seu seja diferente, informe-o na instrução acima 🙂

Depois disso, o banco employees será criado no MySQL:

Lembrando que o BD que utilizamos já virá populado, contendo mais de 300,000 empregados registrados. Situação parecida ao que descrevemos anteriormente:

Configurando aplicação

Após criar o banco de dados, estamos prontos para mapeá-lo em nosso projeto Django. Para isso, partiremos de uma aplicação “zerada”, apenas com o projeto e uma app criada. Além disso, precisamos instalar, obviamente, o Django e o mysqlclient em nossa virtualenv:


Além disso, precisamos configurar o projeto para se comunicar com o banco de dados que acabamos de importar. Para isso, no arquivo settings.py do nosso projeto, determinamos seus parâmetros de conexão:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'employees',
        'USER': 'root',
        'PASSWORD': 'root',
        'HOST': 'localhost',
        'PORT': '3306'
    }
}

Com isso, temos nossa aplicação criada e se comunicando com o banco de dados \o

Mapeando o banco de dados no Django

Depois de configurar a aplicação, chegou a hora tão esperada: mapear o banco de dados para nosso arquivo models.py 😀

Para isso, é muito simples (e você vai se impressionar com isso). Tudo que temos que fazer é abrir o terminal integrado do PyCharm e digitar o seguinte comando:

python manage.py inspectdb > nome_da_app.models.py

Lembrando que “nome_da_app” deve ser alterada pelo nome da sua app no projeto, hein!? 🙂

Após isso, no arquivo models.py da nossa aplicação, teremos o seguinte resultado:

from django.db import models


class Departments(models.Model):
    dept_no = models.CharField(primary_key=True, max_length=4)
    dept_name = models.CharField(unique=True, max_length=40)

    class Meta:
        managed = False
        db_table = 'departments'


class DeptEmp(models.Model):
    emp_no = models.ForeignKey('Employees', models.DO_NOTHING, db_column='emp_no', primary_key=True)
    dept_no = models.ForeignKey(Departments, models.DO_NOTHING, db_column='dept_no')
    from_date = models.DateField()
    to_date = models.DateField()

    class Meta:
        managed = False
        db_table = 'dept_emp'
        unique_together = (('emp_no', 'dept_no'),)


class DeptManager(models.Model):
    emp_no = models.ForeignKey('Employees', models.DO_NOTHING, db_column='emp_no', primary_key=True)
    dept_no = models.ForeignKey(Departments, models.DO_NOTHING, db_column='dept_no')
    from_date = models.DateField()
    to_date = models.DateField()

    class Meta:
        managed = False
        db_table = 'dept_manager'
        unique_together = (('emp_no', 'dept_no'),)


class Employees(models.Model):
    emp_no = models.IntegerField(primary_key=True)
    birth_date = models.DateField()
    first_name = models.CharField(max_length=14)
    last_name = models.CharField(max_length=16)
    gender = models.CharField(max_length=1)
    hire_date = models.DateField()

    class Meta:
        managed = False
        db_table = 'employees'


class Salaries(models.Model):
    emp_no = models.ForeignKey(Employees, models.DO_NOTHING, db_column='emp_no', primary_key=True)
    salary = models.IntegerField()
    from_date = models.DateField()
    to_date = models.DateField()

    class Meta:
        managed = False
        db_table = 'salaries'
        unique_together = (('emp_no', 'from_date'),)


class Titles(models.Model):
    emp_no = models.ForeignKey(Employees, models.DO_NOTHING, db_column='emp_no', primary_key=True)
    title = models.CharField(max_length=50)
    from_date = models.DateField()
    to_date = models.DateField(blank=True, null=True)

    class Meta:
        managed = False
        db_table = 'titles'
        unique_together = (('emp_no', 'title', 'from_date'),)

Exatamente a mesma estrutura (com seus atributos e relacionamentos) presentes no banco de dados que incorporamos ao MySQL da nossa máquina. Bem legal, né!?

Imagine ter que mapear todas essas entidades, avaliando seus tipos de dados e relações… Seria um trabalho bem cansativo, concorda? Com o Django, um simples comando consegue resolver este problema 🙂

Agora, já estamos prontos para utilizar todo o poder do ORM do Django para manipular o banco de dados e, consequentemente, criar nossa nova aplicação \o

Relacionamento 1-1, 1-N e N-N com Django

No modelo relacional, existem três tipos de associação entre entidades (tabelas) distintas. Estas relações são utilizadas para mapear como as tabelas interagem entre si e podem ser classificadas de três formas: 1-1 (um para um), 1-N (um para muitos) e N-N (muitos para muitos).

Sendo assim, veremos neste artigo como funciona e como implementar os três tipos de relacionamento no Django.

Relacionamento 1-1

Assim como o próprio nome supõe, o relacionamento 1-1 define que um item de uma entidade só poderá se relacionar com um item de outra entidade. Por exemplo, supondo que temos as entidades Cliente e Endereço que se relacionam de forma 1-1, um cliente só poderá possuir um endereço, que também só pode estar relacionado a um cliente.

Para criar este tipo de relacionamento no Django, no arquivo models.py, precisamos criar um campo que armazene o ID do endereço na entidade cliente do tipo OneToOneField:

class Endereco(models.Model):
        # Definimos seus atributos

class Cliente(models.Model):
        # Definimos seus atributos
      endereco = models.OneToOneField(Endereco, on_delete=models.SET_NULL, null=True)

Desta forma, a classe Cliente irá armazenar o ID do Endereço que cada cliente possuirá. O código completo das classes Endereço e Cliente podem ser vistas abaixo:

class Endereco(models.Model):
    rua = models.CharField(max_length=200, null=False, blank=False)
    numero = models.IntegerField(null=False, blank=False)
    complemento = models.CharField(max_length=200, null=False, blank=False)
    bairro = models.CharField(max_length=50, null=False, blank=False)
    cidade = models.CharField(max_length=100, null=False, blank=False)
    pais = models.CharField(max_length=50, null=False, blank=False)

    def __str__(self):
        return self.rua

class Cliente(models.Model):
    SEXO_CHOICES = (
        ("F", "Feminino"),
        ("M", "Masculino"),
        ("N", "Nenhuma das opções")
    )

    nome = models.CharField(max_length=100, null=False, blank=False)
    data_nascimento = models.DateField(null=False, blank=False)
    email = models.EmailField(null=False, blank=False)
    profissao = models.CharField(max_length=50, null=False, blank=False)
    sexo = models.CharField(max_length=1, choices=SEXO_CHOICES, blank=False, null=False)
    endereco = models.OneToOneField(Endereco, on_delete=models.SET_NULL, null=True)

Após definir as classes acima, precisamos criar a migração para efetivar as alterações no banco de dados e, assim, criar as tabelas no banco de dados. Para isso, utilizamos os comandos abaixo:

python manage.py makemigrations

python manage.py migrate

Isso fará com que as tabelas sejam criadas no banco de dados com a seguinte estrutura:

Relacionamento 1N

O relacionamento 1N determina que um item de uma tabela pode se relacionar com vários itens de uma outra tabela. Continuando o exemplo acima, podemos determinar que um cliente pode realizar diversos pedidos em um restaurante, porém cada pedido só pode possuir um cliente atrelado a ele.

Para criar este relacionamento no Django, utilizamos um campo do tipo ForeignKey, como podemos ver abaixo:

class Pedido(models.Model):
    cliente = models.ForeignKey("Cliente", on_delete=models.CASCADE, related_name='pedidos')

Isso fará com que a tabela Pedidoarmazene o ID do cliente de cada relação. O código completo das classes Pedido e Cliente pode ser visto abaixo:

class Pedido(models.Model):
    STATUS_CHOICES = (
        ("P", "Pedido realizado"),
        ("F", "Fazendo"),
        ("E", "Saiu para entrega"),
    )
    cliente = models.ForeignKey("Cliente", on_delete=models.CASCADE, related_name='pedidos')
    observacoes = models.CharField(max_length=300, null=False, blank=False)
    data_pedido = models.DateTimeField(default=timezone.now)
    valor = models.FloatField(blank=False, null=False)
    status = models.CharField(max_length=1, choices=STATUS_CHOICES, blank=False, null=False)

    def __str__(self):
        return self.cliente.nome

class Cliente(models.Model):
    SEXO_CHOICES = (
        ("F", "Feminino"),
        ("M", "Masculino"),
        ("N", "Nenhuma das opções")
    )

    nome = models.CharField(max_length=100, null=False, blank=False)
    data_nascimento = models.DateField(null=False, blank=False)
    email = models.EmailField(null=False, blank=False)
    profissao = models.CharField(max_length=50, null=False, blank=False)
    sexo = models.CharField(max_length=1, choices=SEXO_CHOICES, blank=False, null=False)
    endereco = models.OneToOneField(Endereco, on_delete=models.SET_NULL, null=True)

Após definir as classes acima, precisamos criar a migração para efetivar as alterações no banco de dados e, assim, criar as tabelas no banco de dados. Para isso, utilizamos os comandos abaixo:

python manage.py makemigrations

python manage.py migrate

Isso fará com que as tabelas sejam criadas no banco de dados com a seguinte estrutura:

Agora, a tabela Pedido armazenará, além de todos os seus atributos, o ID do cliente. Assim, um cliente poderá estar relacionado a vários pedidos, porém um pedido só pode se relacionar com um único cliente.

Relacionamento NN

O relacionamento NN define que um item de uma tabela pode se relacionar com vários itens de uma outra tabela e vice-versa. Por exemplo, podemos determinar que um pedido pode possuir diversos produtos relacionados a ele, assim como um mesmo produto pode estar relacionado a diversos pedidos diferentes.

Para criar este tipo de relacionamento, utilizamos um campo do tipo ManyToManyField, como podemos ver abaixo:

class Produto(models.Model):
    nome = models.CharField(max_length=50, null=False, blank=False)
    descricao = models.CharField(max_length=200, null=False, blank=False)
    valor = models.FloatField(null=False, blank=False)

    def __str__(self):
        return self.nome

class Pedido(models.Model):
    STATUS_CHOICES = (
        ("P", "Pedido realizado"),
        ("F", "Fazendo"),
        ("E", "Saiu para entrega"),
    )
    cliente = models.ForeignKey("Cliente", on_delete=models.CASCADE, related_name='pedidos')
    observacoes = models.CharField(max_length=300, null=False, blank=False)
    data_pedido = models.DateTimeField(default=timezone.now)
    valor = models.FloatField(blank=False, null=False)
    status = models.CharField(max_length=1, choices=STATUS_CHOICES, blank=False, null=False)
    produtos = models.ManyToManyField(Produto)

    def __str__(self):
        return self.cliente.nome

Após definir as classes acima, precisamos criar a migração para efetivar as alterações no banco de dados e, assim, criar as tabelas no banco de dados. Para isso, utilizamos os comandos abaixo:

python manage.py makemigrations

python manage.py migrate

Isso fará com que as tabelas sejam criadas no banco de dados com a seguinte estrutura:

Para este tipo de relacionamento, uma tabela “auxiliar” será criada para armazenar os IDs do pedido e do produto que se relaciona.

A tabela clientes_pedido_produtosirá armazenar o id do pedido e o id do produto que fazem relação. Desta forma, um pedido pode se relacionar com diferentes produtos e um produto pode estar relacionado a diferentes pedidos.

Conclusão

Vimos neste artigo o quão simples é criar os três tipos de relacionamento em bancos de dados relacionais utilizando o ORM do Django. Com isso, agora podemos criar nossas aplicações e estruturar nosso banco de dados da melhor forma possível.

O que é Django?

O Django é um framework gratuito e de código aberto escrito em Python para desenvolvimento web. Sua utilização permite a construção de aplicações web de alto desempenho.

O que é um Framework?

O framework é um facilitador no desenvolvimento de diversas aplicações, e sem dúvida, sua utilização poupa tempo e custos para quem utiliza, pois de forma mais básica, é um conjunto de bibliotecas utilizadas para criar uma base onde as aplicações são construídas, um otimizador de recursos. Tem como principal objetivo resolver problemas recorrentes com uma abordagem mais genérica. Ele permite ao desenvolvedor focar nos “problemas” da aplicação, não na arquitetura e configurações.

História do Django

Lançado em 2005 sob a licença BSD (de código aberto), o Django foi desenvolvido inicialmente como um sistema de gerenciamento de um site jornalístico. Tem como seus co-criadores os desenvolvedores Adrian Holovaty e Simon Willison. A escolha do nome “Django” foi inspirado no músico de jazz Django Reinhardt, considerado um dos melhores e mais influentes guitarristas de todos os tempos. \o/

Padrão MTV

O Django utiliza o padrão de projeto MTV (Model, Template e View), que é basicamente:

Model: Onde acontece toda interação com o banco de dados;

Template: Onde acontece a renderização dos dados para uma visualização mais intuitiva, em outras palavras, a interação do usuário com o site em Django;

E a View: Lógica sobre os dados. A camada responsável pelas regras de negócio do sistema Django.

Por ser popular, o Django possui uma grande comunidade de desenvolvedores. Com isso, fica muito mais fácil encontrar materiais de estudo e programadores dispostos a se ajudarem.

Utiliza o princípio Don´t Repeat Yourself ou simplesmente DRY, permitindo que as aplicações sejam desenvolvidas com a maior quantidade de aproveitamento de código possível.

Concluindo:

Com isso, vimos algumas das principais características do Django, o que o torna um framework muito utilizado e que, com certeza, você deve levar em consideração quando iniciar um projeto. =)

Utilizando arquivos estáticos em um projeto Django

A utilização de arquivos estáticos no Django necessita de algumas configurações para ser feita, como veremos neste artigo 🙂

Configurando aplicação

Com a aplicação aberta no PyCharm, precisamos configurar o diretório em que os arquivos estáticos (JS, CSS e IMG) serão armazenados. Para isso, vamos até o final do arquivo settings.py do nosso projeto até encontrar a configuração STATIC_URL, é ela quem define o diretório que os arquivos estáticos serão armazenados.

Por padrão, o Django armazena os arquivos estáticos em um diretório chamado static, localizado na aplicação. Sendo assim, é lá que vamos armazenar os arquivos CSS, JS e IMG da aplicação.

Para isso, o primeiro passo é criar um diretório chamado static na aplicação e, dentro do diretório static, criar uma outra pasta com o nome da aplicação. Por exemplo, se a aplicação possuir o nome “minha_aplicacao”, precisamos criar um diretório static/minha_aplicacao dentro da app que estamos desenvolvendo:

Note que na imagem acima, estamos criando um diretório com o mesmo nome da aplicação “app” dentro do diretório “static” e, dentro do diretório “app”, criamos as pastas para armazenar os arquivos css, js e img.

Com isso, só precisamos armazenar os arquivos estáticos do projeto em seu respectivo diretório. Como exemplo, vamos criar um arquivo css simples e armazená-lo no diretório static/app/css com o nome style.css e com o seguinte conteúdo:

body {
  background-color: lightblue;
}

h1 {
  color: navy;
  margin-left: 30px;
}

Utilizando arquivos nos templates

Agora que já configuramos a localização dos arquivos estáticos e criamos o css de exemplo, precisamos importá-lo em nossos templates. Para isso, o processo é bem simples:

1 – Carregamos a tag static do Django em nosso template (linha 2);

2 – Carregamos o arquivo css utilizando a tag (linha 7). Note que precisamos determinar o caminho, a partir do diretório static, do arquivo css que criamos anteriormente.

<!DOCTYPE html>
{% load static %}
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Página de testes</title>
    <link rel="stylesheet" href="{% static 'app/css/style.css' %}">
</head>
<body>

<h1>Olá, mundo</h1>

</body>
</html>

Testando aplicação

Agora, ao executar a aplicação e renderizar o template com o css importado, teremos o seguinte resultado:

Deploy de uma aplicação Django no Heroku

Hoje, a principal forma de entrega e uso de uma aplicação é por meio da nuvem. É por lá que as aplicações são armazenadas e acessadas. Sendo assim, é imprescindível que uma aplicação seja armazenada em algum servidor e disponível pela internet.

Pensando nisso, veremos neste artigo como realizar o Deploy de uma aplicação Django e disponibilizá-la no Heroku, serviço de armazenamento em nuvem de aplicações.

Clonando o repositório da aplicação

Como exemplo, iremos utilizar a aplicação feita no curso “Django – Fundamentos” aqui da TreinaWeb. Apesar de ser uma aplicação simples, será um ótimo exemplo para testes.

Para realizar o clone do projeto, vamos até o CMD (se você usa o Windows) ou Terminal (caso você use o macOS ou Linux) e utilizamos o seguinte comando:

git clone https://github.com/treinaweb/treinaweb-django-fundamentos.git

Feito isso, o projeto será baixado em seu computador e você terá todo o seu código-fonte.

Criar conta no Heroku

Após baixar o código-fonte do projeto, precisamos criar uma conta (ou realizar o login) no Heroku. O processo é bem simples, basta preencher o formulário na página de cadastro do site (https://signup.heroku.com/):

Caso você já possua uma conta no Heroku, só será necessário realizar o login (https://id.heroku.com/login).

Depois disso, você será redirecionado para a página inicial do Heroku:

Criar app no Heroku

Depois de criar uma conta no Heroku, precisamos criar uma app para armazenar a aplicação Django. Para isso, na página inicial, clicamos no botão “Create New App”. Depois, na próxima página, definimos o nome da aplicação que estamos criando e clicamos no botão “Create App”:

Com isso, seremos redirecionados para a página de configuração da aplicação. É nela que configuramos o servidor em que a aplicação será armazenado.

Instalar o Heroku CLI

Para que seja possível enviar o código-fonte do projeto para o servidor que acabamos de criar, precisamos instalar o CLI (Command Line Interface) do Heroku. É com ele que conseguimos executar determinados comandos utilizando nosso computador para gerenciar o servidor da aplicação.

Para isso, há uma página que contém todas as informações necessárias para esse processo. Lembrando que o Heroku CLI é multi-plataforma, ou seja, poderá ser utilizado em qualquer SO (Windows, macOS ou Linux).

Todo o processo de instalação está descrito na documentação do Heroku (https://devcenter.heroku.com/articles/heroku-cli) e é bastante simples.

Se você utiliza o macOS, você precisa digitar o seguinte comando em seu terminal:

brew tap heroku/brew && brew install heroku

Caso você utilize o Linux, o comando é o seguinte:

sudo snap install --classic heroku

Agora, caso você utilize o Windows, você precisará baixar e executar o instalador do Heroku CLI, também disponível na página citada acima:

Lembrando que, para qualquer SO, é necessário possuir o Git instalado. Mas, já que você fez o clone do repositório do projeto, isso já deve estar funcionando 🙂

Logar no Heroku CLI

Depois de baixar e instalar o Heroku CLI, precisamos logar com nossa conta na ferramenta. Para isso, vamos até o CMD (ou Terminal) e digitamos o seguinte comando:

heroku login

Uma mensagem no terminal será exibida e podemos clicar em qualquer tecla do teclado. Neste momento, o navegador irá abrir uma página para realizarmos o login no Heroku. Após digitarmos nossos dados de acesso, clicamos no botão “Login” e o processo será encerrado com sucesso:

Configurar Projeto

Com todas as configurações do Heroku prontas, chegou a hora de configurarmos a aplicação que será armazenada no servidor. Para isso, o primeiro passo é instalar a biblioteca django-heroku, responsável por automatizar as configurações do nosso projeto com o Heroku.

Instalar o django-heroku

Para instalar o django-heroku, vamos até a janela de configuração da nossa virtualenv do PyCharm (Arquivo > Settings > Project Interpreter, caso você utilize o Windows ou Linux ou PyCharm Community Edition > Preferences > Project Interpreter, caso você utilize o macOS), clicamos no botão “+” no canto inferior esquerdo e buscamos a biblioteca pelo seu nome, como podemos ver abaixo:

Depois disso, a biblioteca será instalada em nossa virtualenv e estaremos prontos para configurá-la em nosso projeto. Sendo assim, vamos até o arquivo settings.py e ativamos o django-heroku adicionando o seguinte conteúdo no final do arquivo :

# Configure Django App for Heroku.
import django_heroku
django_heroku.settings(locals())

Feito isso, as configurações do Heroku em nossa aplicação estão prontas.

Criar Procfile

Depois de instalar o django-heroku, precisamos criar o arquivo Procfile na raiz do nosso projeto. É ele quem vai definir qual arquivo será usado para processar as requisições da nossa aplicação. No Django, esse arquivo é o wsgi.py, localizado na pasta da nossa aplicação.

Sendo assim, criamos um arquivo de texto simples com o nome Procfilee salvamos na raiz do nosso projeto. Dentro dele, colamos o seguinte conteúdo:

web: gunicorn tw_clientes.wsgi

Lembrando que o nome da sua aplicação pode variar, caso você não esteja utilizando o mesmo projeto citado anteriormente. Se este for o seu caso, altere o “tw_cliente.wsgi” para o nome da sua aplicação.

Depois disso, precisamos instalar a biblioteca gunicorn, servidor HTTP para aplicações Python. O processo é o mesmo que o django-heroku, porém devemos pesquisar por gunicornna janela de instalação de bibliotecas:

Criar requirements.py

Depois disso, precisamos criar o arquivo requirements.py para armazenar as bibliotecas utilizadas no projeto. Lembrando que você precisa estar com a virtualenv ativa no PyCharm.

Sendo assim, o comando para gerar o arquivo requirements.pycom base nas bibliotecas instaladas na virtualenv do projeto é o seguinte:

pip freeze > requirements.txt

Com isso, o arquivo requirements.txtserá criado na raiz do projeto com o seguinte conteúdo:

dj-database-url==0.5.0
Django==2.1.7
django-heroku==0.3.1
gunicorn==19.9.0
mysqlclient==1.4.2
psycopg2==2.7.7
pytz==2018.9
whitenoise==4.1.2

São essas as bibliotecas utilizadas em nosso projeto. Lembrando que o conteúdo deste arquivo pode variar caso você tenha mais bibliotecas em sua virtualenv.

Lembrando que a lista de bibliotecas utilizadas pode ser vista na janela de configurações do PyCharm (Arquivo > Settings > Project Interpreter, caso você utilize o Windows ou Linux ou PyCharm Community Edition > Preferences > Project Interpreter, caso você utilize o macOS):

Realizar o Deploy

Finalmente, após todas as configurações, estamos prontos para subir nosso projeto no Heroku \o/.

Subindo aplicação

Para isso, vamos até o terminal e digitamos o seguinte comando:

heroku git:remote -a django-treinaweb
git add .
git commit -m "Deploy da aplicação"
git push -u heroku master

Depois disso, uma mensagem será exibida no terminal indicando que o deploy foi feito com sucesso:

Clicando no link indicado, somos redirecionados para a página da aplicação que acabou de ser armazenada. Neste momento, a página que será exibida terá o seguinte visual:

Como sabemos, essa é a página de erro do Django. Sendo assim, ao que tudo indica, o Deploy foi feito com sucesso. Sendo assim, se navegarmos até a página https://django-treinaweb.herokuapp.com/clientes/listar teremos o seguinte:

O erro acima indica que o Django não conseguiu encontrar as tabelas que estamos utilizando no banco de dados. E isso faz sentido, já que, até o momento, não migramos o conteúdo dos arquivos de migração para o Heroku. Sendo assim, este é o último passo a ser realizado.

Criando banco de dados

Para executar o comando responsável por criar o banco de dados no heroku, vamos até o terminal e digitamos o seguinte comando:

heroku run python manage.py migrate

O comando acima irá executar as migrações no banco de dados do Heroku e criar toda a sua estrutura:

Agora, ao retornar para a página anterior, podemos ver que a aplicação está sendo executada sem qualquer erro:

Inclusive, podemos utilizar qualquer recurso da nossa aplicação, como o cadastro de novos clientes:


Agora, toda a nossa aplicação já está disponível e funcional diretamente da nuvem através do Heroku 🙂

Django ou Flask, eis a questão.

O ecossistema do Python é repleto de ótimos frameworks, dentre eles se destacam o Django e o Flask, dois frameworks para desenvolvimento web e que possuem diversos adeptos pelo mundo. Mas você já se perguntou quando usar um deles e quais são suas principais diferenças? Bom, é isso que veremos neste artigo. 🙂

Django


O Django é um framework de desenvolvimento rápido para web. Escrito em Python, o Django foi lançado em 2005 e, atualmente, está na versão 2.2. Criado originalmente para gerenciar um site jornalístico na cidade de Lawrence, Kansas, tornou-se um projeto Open Source e logo caiu no gosto dos desenvolvedores intusiastas em Python.

Utiliza o padrão de projeto próprio denominado MTV (model-template-view), bem similar ao já conhecido MVC (model-view-controller), que separa as responsabilidades da aplicação em camadas, aumentando a legibilidade do código e organização da aplicação.
A principal premissa do Django é seu princípio DRY (Don’t Repeat Yourself), fazendo com que o desenvolvedor aproveite o máximo de código já criado em outros módulos da aplicação, evitando ao máximo a repetição e reescrita de código.

Tá, mas onde eu vou usar o Django?

O Django é mais recomendado quando estamos desenvolvendo um projeto mais profissional e complexo (apesar de ser amplamente utilizado em pequenos projetos também). Possui um amplo conjunto de ferramentas que facilita a criação destas aplicações, como:

  • Django ORM: Permite que você conecte seu projeto com vários bancos de dados relacionais (PostgreSQL, Oracle, MySQL, SQLite, etc) e gerencie seus dados de forma simplificada, sem a necessidade de escrever código SQL.
  • Django Admin: Possui uma área administrativa integrada ao projeto para gerenciamento de todos os dados da aplicação, facilitando a criação de um projeto CMS (sistema de gerenciamento de conteúdo).
  • Django Templates: Com o Django, a criação das páginas HTML para exibição de conteúdo é feita de forma simples e rápida, permitindo a herança de templates e concatenação de código Python com HTML.
  • Comunidade: A comunidade por trás do Django é incrível. Diversos projetos são desenvolvidos diariamente, tornando seu ecossistema cada vez maior.

Flask


O Flask é, assim como o Django, um framework (ou microframework) web de código aberto. Lançado em 2010, o Flask também é amplatamente utilizado em projetos ao redor do mundo.

Diferente do Django, que já possui um conjunto de ferramentas integradas ao Framework, o Flask pode ser comparado a um conjunto de Lego. Ao instalarmos o Flask, apenas duas bibliotecas são instaladas em conjunto, permitindo que o desenvolvedor instale apenas o que o projeto irá necessitar, isso torna a aplicação muito mais leve e rápida de ser executada já que, por exemplo, não precisamos de uma biblioteca para envio de e-mail se a aplicação não irá utilizar deste recurso.

É chamado de microframework justamente por manter um núcleo simples, porém estendível. Não possui camada de acesso ao banco de dados, validação de formulários ou qualquer outro componente. Para isso, é necessário instalar bibliotecas de terceiros e, assim, prover determinada funcionalidade. Isso torna a construção de aplicações com Flask mais simples e sua curva de apendizado mais leve.

Tá, mas onde eu vou usar o Flask?

Como dito anteriormente, o Flask é amplamente utilizado em pequenas aplicações ou microsserviços, embora possamos criar grandes projetos com o Flask.
De todas as características do Flask, é possível ressaltar as seguintes:

  • Simplicidade: Por ser um framework minimalista, o Flask fornece os recursos necessários para a criação da base de uma aplicação, como seu sistema de templates, rotas e servidor web embutido para testes. A partir daí, qualquer que seja a necessidade, o desenvolvedor poderá utilizar de bibliotecas externas para incrementar sua aplicação. Isso faz com que o projeto seja o mais simples possível, sem tantos arquivos desnecessários;
  • Velocidade: Alinhado à simplicidade do projeto, o Flask possui um desempenho superior quando comparado ao Django.
  • Comunidade: Assim como o Django, o Flask possui uma ampla comunidade com vários desenvolvedores espalhados ao redor do mundo. Por isso, diversas novas bibliotecas estão sendo diariamente disponibilizadas para uso.

E ai? Deciciu?

Bom, apesar do Flask e do Django possuírem características similares, seu uso é um pouco distinto. Podemos considerar que o Django é mais recomendado para aplicações maiores e que exigem uma complexidade superior, já que possui diversas facilidades embutidas em seu core, além de uma comunidade gigantesca.
Já o Flask é mais utilizado em pequenas aplicações e microsserviços, como APIs. Ou seja, aplicações que devem ser executadas de forma mais rápida.
A partir daí, a escolha entre as duas ferramentas deve ser feita pelo desenvolvedor, que irá analisar o projeto e determinar qual framework se encaixa melhor em seu escopo.

Criando ambientes virtuais para projetos Python com o Virtualenv

Quando estamos desenvolvendo diversos projetos em Python, é comum utilizarmos diferentes versões de uma mesma biblioteca entre este projetos. Por exemplo, imagine que estamos desenvolvendo o projeto x com a biblioteca mysqlclient em sua versão 1.0 e o projeto y com a mesma biblioteca, porém na versão 2.0. Como faríamos para gerenciar estas dependências e o sistema operacional saber qual versão correta executar quando estivermos em cada projeto?

Esta é uma tarefa um tanto quanto complexa para o SO gerenciar, podendo acarretar em conflitos entre as versões e causar muita dor de cabeça. Sendo assim, o mais comum é utilizarmos diferentes ambentes virtuais, chamados de virtualenvs, um para cada projeto. E é isso que veremos neste artigo 😀

O que é uma virtualenv?

Como dito acima, um problema muito comum é quando precisamos utilizar diversas versões de uma mesma biblioteca em diferentes projetos Python. Isso pode acarretar em conflitos entre as versões e muita dor de cabeça para o desenvolvedor. Para resolver este problema, o mais correto é a criação de um ambiente virtual para cada projeto.

Basicamente, um ambiente virtual empacota todas as dependências que um projeto precisa e armazena em um diretório, fazendo com que nenhum pacote seja instalado diretamente no sistema operacional. Sendo assim, cada projeto pode possuir seu próprio ambiente e, consequentemente, suas bibliotecas em versões específicas.

Como funciona uma virtualenv?

O funcionamento de uma virtualenv é bem simples. Basicamente, uma cópia dos diretórios necessários para que um programa Python seja executado é criada, incluindo:

  • PIP (Gerenciador de pacotes);
  • A versão do Python utilizada (2.x ou 3.x);
  • Dependências instaladas com o pip (armazenadas no diretório site-packages);
  • Seu código fonte;
  • Bibliotecas comuns do Python.

Isso faz com que as dependências sejam sempre instaladas em uma virtualenv específica, não mais no sistema operacional. A partir daí, cada projeto executa seu código-fonte utilizando sua virtualenv própria 🙂

Instalando a virtualenv

A instalação de uma virtualenv é feita utilizando o pip, gerenciador de pacotes do Python. Já falamos sobre o PIP em um outro artigo aqui do blog. Caso você não saiba do que se trata ou como instalá-lo, sugiro você dar uma passada por lá 🙂
Após instalar o pip, utilizamos o comando abaixo para instalar o pacote virtualenv em nosso computador:

pip install virtualenv

Feito isso, o pacote estará instalado e pronto para ser utilizado. Agora já podemos criar e gerenciar nossos ambientes virtuais.

Criando uma nova virtualenv

O processo de criação de uma virtualenv é bastante simples e pode ser feito utilizando um único comando, como podemos ver abaixo:

virtualenv nome_da_virtualenv

O mais comum é criar a virtualenv na raiz do projeto que ela irá pertencer. Isso permite uma organização maior das virtualenvs que possuímos em nosso computador:

Com isso, criamos a virtualenv do projeto chamada “venv”. É ela quem vai comportar todos os pacotes necessários para a execução do projeto.

Ativando uma virtualenv

Após criar uma virtualenv, precisamos ativá-la para que possamos instalar os pacotes necessários do projeto. Para isso, utilizamos o seguinte comando:

  • souce nome_da_virtualenv/bin/activate (Linux ou macOS)
  • nome_da_virtualenv\Scripts\activate (Windows)

O comando acima irá ativar a virutalenv e teremos um retorno similar ao ilustrado abaixo:

Note que o nome da virtualenv, agora, é exibido antes do caminho do diretório em que estamos. Isso indica que a virtualenv foi ativada com sucesso.

Desativando uma virtualenv

Para desativar uma virtualenv utilizamos o comando deactivate, como podemos ver abaixo:

Instalando pacotes

Com a virtualenv ativada, podemos instalar os pacotes necessários do projeto utilizando o próprio PIP:

Com isso, instalamos o pacote Django, em sua versão mais atual, na virtualenv do projeto “projeto_python”.

Agora, se precisarmos instalar uma outra versão do Django em outro projeto, bastaria criar uma nova virtualenv e realizar o mesmo processo:

Com isso, teremos diferentes versões do Django instaladas no mesmo sistema operacional, porém isoladas em cada ambiente. Sendo assim, o projeto “projeto_python” utiliza a versão mais recente (2.1.3) e o “projeto_python_2” utiliza a versão 2.11, tudo de forma isolada entre os projetos:


Concluindo

Com isso, vimos o quão importante e simples é utilizar uma virtualenv para cada projeto. Com isso, garantimos que as versões de cada pacote sejam isoladas, permitindo que não haja conflito entre elas.

Criando um Chatbot com Python

Os chatbots são aplicações que trocam e gerenciam mensagens. Atualmente, várias empresas estão investindo neste segmento para a criação de assistentes virtuais (robôs que interagem com o usuário e realizam determinadas tarefas cotidianas).

Neste artigo veremos como criar um chatbot com Python que interage com o usuário e aprende enquanto conversa em um jogo de perguntas e respostas.

Instalando as ferramentas

O primeiro passo para o desenvolvimento do nosso chatbot é instalar as ferramentas necessárias. Para isso, vamos precisar do Python, PIP e da biblioteca Chatterbot. Também vamos utilizar o PyCharm em sua versão Community para ajudar no desenvolvimento, mas seu uso é opicional.

O download do Python pode ser feita por meio do seu site oficial e o processo é bem simples (next > next > finish).

Já o PIP, gerenciador de pacotes do Python, pode ser baixado também por meio de seu site oficial. Todo o processo de instalação do PIP pode ser visto neste post do blog da TreinaWeb.

Por fim, com o Python e o PIP instalados, precisamos instalar a biblioteca Chatterbot. Para isso, após criar o projeto no PyCharm, vamos até a aba “Project Interpreter”, localizado em “Preferences” dentro do PyCharm. Lá, vamos buscar pela biblioteca Chatterbot e realizar sua instalação, como podemos ver abaixo:

Feito isso, todas as ferramentas necessárias já estão instaladas e prontas para serem utilizadas.

Criando o Chatbot

O processo de criação do Chatbot é bem simples. Basicamente, vamos criar uma lista de perguntas e respostas que serão usadas como aprendizado inicial do nosso Bot. A partir daí, utilizaremos alguns métodos para que todas as perguntas e respostas que vamos informando para ele, sejam analisadas, processadas e aprendidas conforme o tempo. Veremos abaixo todo o código detalhado:

from chatterbot.trainers import ListTrainer
from chatterbot import ChatBot

O primeiro passo para a criação do nosso chatbot é importar o método ListTrainer responsável por permitir que uma lista de strings seja utilizada no processo de aprendizagem do Bot. Após isso, importamos o construtor Chatbot para que possamos criá-lo em nosso programa.

Feito isso, precisamos inicializar nosso Chatbot e determinar a lista inicial de mensagens que serão utilizadas como base para o aprendizado do Bot:

bot = ChatBot('TW Chat Bot')

conversa = ['Oi', 'Olá', 'Tudo bem?', 'Tudo ótimo', 
            'Você gosta de programar?', 'Sim, eu programo em Python']

bot.set_trainer(ListTrainer)
bot.train(conversa)

Com isso, nós registramos três perguntas. Por padrão, cada resposta se refere ao item anterior da lista. Por exemplo, a string ‘Olá’ se refere como resposta da pergunta ‘Oi’. Já a string ‘Tudo ótimo’ é resposta da pergunta ‘Tudo bem?’ e assim por diante.

Após isso, definimos, através do método train(), que utilizaremos a lista conversa como ponto de partida para o aprendizado do Bot.

Finalmente, criamos um loop infinito que vai capturar a pergunta do usuário, buscar uma possível resposta e retornar ao usuário. Definimos, também, que se o grau de confiança da resposta for menor que 0.5, o Bot vai informar que ainda não sabe responder tal pergunta:

while True:
    pergunta = input("Usuário: ")
    resposta = bot.get_response(pergunta)
    if float(resposta.confidence) > 0.5:
        print('TW Bot: ', resposta)
    else:
        print('TW Bot: Ainda não sei responder esta pergunta')

Sendo assim, o código final do nosso Chatbot pode ser visto abaixo:

from chatterbot.trainers import ListTrainer
from chatterbot import ChatBot

bot = ChatBot('TW Chat Bot')

conversa = ['Oi', 'Olá', 'Tudo bem?', 'Tudo ótimo', 'Você gosta de programar?', 'Sim, eu programo em Python']

bot.set_trainer(ListTrainer)
bot.train(conversa)

while True:
    pergunta = input("Usuário: ")
    resposta = bot.get_response(pergunta)
    if float(resposta.confidence) > 0.5:
        print('TW Bot: ', resposta)
    else:
        print('TW Bot: Ainda não sei responder esta pergunta')

Vale ressaltar que as perguntas e respostas do nosso ChatBot vão sendo armazenadas em um banco de dados SQLite criado automaticamente. Um outro ponto importante é que o processo de aprendizado é um pouco lento, então você terá que conversar alguns minutos com seu ChatBot até que ele aprenda novas perguntas e suas respectivas respostas.

Após isso, podemos executar nosso ChatBot e conversar com nosso novo amigo. Para isso, clicamos com o botão direito no arquivo e selecionamos a opção “Run”:

Nosso ChatBot será inicializado e nós podemos trocar mensagens com ele. Após alguns minutos de conversa, você perceberá que o ChatBot fará perguntas que não estão cadastradas em nossa lista conversa. Estas perguntas são aprendidas com o tempo e armazenadas no banco de dados:

Nem sempre as respostas possuem exatidão, mas este processo vai melhorando com o tempo. Basta você indicar o caminho correto para o Bot que ele aprenderá mais rápido.

Concluindo

Neste artigo vimos como é simples criar um ChatBot com Python. O processo de aprendizado, no início, é demorado, mas vai melhorando com o tempo. Após alguns minutos de conversa, você terá um amigo pra dialogar nas horas vagas sobre os assuntos que você mais gosta. 😀

JUNTE-SE A MAIS DE 150.000 PROGRAMADORES