The source content for blog.juliobiason.me
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

208 lines
6.7 KiB

+++
title = "Flask em 40 Minutos ou Menos: Iniciando"
date = 2017-09-25
[taxonomies]
tags = ["python", "flask", "uwsgi", "companion post"]
+++
Uma "breve" explicação de como colocar uma aplicação Flask em produção em 40
minutos. Nessa primeira parte, vamos mostrar como começar um script Flask.
<!-- more -->
Flask é um micro framework web em Python, muito fácil de ser usado e
configurado. Mas o processo inteiro de como começar a aplicação, adicionar
rotas e depois disso partir para colocar em produção pode ser uma pequena dor
de cabeça. Então veremos como fazer todo o processo.
## O VirtualEnv
O primeiro passo de qualquer grande aplicação Python é o VirtualEnv.
VirtualEnv é utilizado para separar as bibliotecas do Python entre aplicações
-- assim você pode ter a biblioteca X numa versão para um determinado projeto
e outra versão para outro projeto. Apenas lembre-se que o VirtualEnv gerencia
apenas bibliotecas do *Python*, portanto não espere que o mesmo controle
versões diferentes de MySQL, por exemplo.
{% note() %}
VirtualEnv não vai cuidar da versão do MySQL, mas pode controlar a versão do driver para Python.")
{% end %}
Para criar um VirtualEnv:
```
python -m venv venv
```
{% note() %}
Se ainda estiver usando Python 2, o comando é `virtualenv venv`.
{% end %}
Depois de executar esse comando, você verá que irá surgir um diretório
`venv`. O último parâmetro é justamente o diretório que será utilizado para
armazenar as informações do VirtualEnv e pode ser criado com qualquer nome e
em qualquer lugar -- inclusive fora do projeto [#venvwrapper]_.
{% note() %}
Alguns pacotes como o [VirtualEnvWrapper](http://virtualenvwrapper.readthedocs.io/en/latest/)_
fazem exatamente isso: Os pacotes são instalados em um diretório separado,
apenas para VirtualEnvs.
{% end %}
Uma vez criado o VirtualEnv, é preciso ativar o mesmo:
```
source venv/bin/active
```
Ou, se estiver usando Windows (sim, você pode rodar os comandos no Windows):
```
venv/Scripts/activate.bat
```
Se tudo deu certo, deve aparecer um `(venv)` no começo do prompt, indicando
que o VirtualEnv está ativo.
Apenas note o seguinte: O VirtualEnv foi projetado para ser destruído e
reconstruído quantas vezes forem necessárias. Por isso, você *não deve*
adicionar o diretório do VirtualEnv no seu repositório;
quem precisar utilizar, que recrie o ambiente.
{% note() %}
Além de não colocar o diretório do virtualenv no seu repositório, tente não
instalar pacotes Python utilizando o sistema de pacotes da sua distribuição.
{% end %}
{% note() %}
O que o `venv` faz é criar vários scripts para as tarefas
relacionadas com o mesmo -- como a ativação do VirtualEnv -- e estes
scripts mantém o caminho de onde foram criados. Com isso, se você adicionar
o mesmo no seu sistema de controle de versão, somente você poderá usar (a
não ser que a outra pessoa tenha exatamente a mesma estrutura de
diretórios). Lembre-se: VirtualEnvs existem para conter as bibliotecas que
você usa e podem ser destruídos e criados livremente -- E como podem ser
criados facilmente, não devem ser incluídos no seu controle de versão -- e
se estou me repetindo, é porque *muitas* pessoas fazem isso, erroneamente.
{% end %}
## Requirements.txt
O modo mais fácil de instalar um pacote -- dentro de um VirtualEnv, obviamente
-- é utilizando o módulo `pip`:
```
python -m pip install flask
```
{% note() %}
Ou, se ainda estiver usando Python 2, `pip install` -- se
realmente preferir, você pode usar `pip install` mesmo com Python 3, pois
ele instala um alias para `python -m pip`.
{% end %}
Mas, como comentado sobre VirtualEnv, onde a ideia é criar, destruir e criar o
ambiente quantas vezes você quiser, ficar passando a lista de pacotes a serem
instalados não faz sentido. Por isso, normalmente é gerado um arquivo com a
lista de requisitos. Esse arquivo, mais por convenção da comunidade do que por
requisito da ferramenta, é o chamado `requirements.txt` Nesse
arquivo você pode colocar a lista de requisitos do seu sistema, incluindo a
versão se necessário.
{% note() %}
E, caso você tenha requisitos que são necessários somente para
desenvolvimento, a convenção diz pra ter um arquivo chamado
`requirements-dev.txt`, cuja a primeira linha é `-r requirements.txt`.
{% end %}
Por exemplo, como a versão do Flask no momento da escrita desse artigo é a
0.12.2, podemos ter um `requirements.txt` com o seguinte conteúdo:
```
flask==0.12.2
```
... indicando que queremos que seja instala a versão 0.12.2. Existe ainda o
operador `~=` [#specifiers]_,que significa "versão compatível com a
indicada". Assim nos precavemos da possibilidade de ser encontrada uma falha
de segurança no Flask, sem precisar sair correndo atrás de todos os
`requirements.txt` com Flask para atualizar a versão e garantimos que,
quando sair a versão 0.13 (ou qualquer outra seguinte) que seja incompatível
com 0.12.2, nosso código ainda vá funcionar.
{% note() %}
Para uma lista de todas as formas de como especificar
versões, olhe o [PEP 440](https://www.python.org/dev/peps/pep-0440/#version-specifiers).
{% end %}
Assim sendo, teremos um `requirements.txt` com o seguinte conteúdo:
```
flask~=0.12.2
```
Mas e para instalar isso? Para isso existe a opção `-r` do pip, que ao invês de
esperar por um nome de pacote para ser instalado, a lista de pacotes é
carregada a partir do arquivo indicado. Então para
gerar o ambiente:
```
python -m pip install -r requirements.txt
```
## O Esqueleto de uma Aplicação Flask
Para verificar se tudo está instalado corretamente, você pode utilizar o
seguinte arquivo de exemplo:
```
from flask import Flask
app = Flask(__name__)
@app.route('/')
def index():
return 'Olá'
```
{% note() %}
Apenas lembre-se de *não* chamar o nome do arquivo de `flask.py`,
porque esse é o nome do módulo e ao invés de importar o módulo do Flask,
ele vai tentar importar o conteúdo do próprio arquivo e, como o objeto
`Flask` não existe, você vai receber um erro de `ImportError: cannot
import name 'Flask'`.
{% end %}
E para executar:
```
FLASK_APP=main.py flask run
```
{% note() %}
Se você percebeu, a variável `FLASK_APP` foi definida com o
nome `main.py`; esse é o nome que eu escolhi para a minha aplicação (e o
nome do arquivo fonte -- aquele que não pode ser `flask.py`),
mas você pode usar o nome que quiser. Apenas lembre-se de usar esse mesmo
nome em `FLASK_APP`.
{% end%}
Se estiver tudo ok, você deve receber a mensagem
```
* Serving Flask app "main"
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
```
E acessando a URL indicada, você deverá ver o "Olá".
Até aqui vimos como instalar e iniciar um projeto Flask básico. No próximo
post vou falar da aplicação Flask em si.