Introdução ao Flask, uma microframework em Python

Neste artigo, vamos apresentar o Flask, um popular microframework para Python que oferece uma alternativa ao gigante que é o Django.

O Flask é projetado para ser leve e flexível, permitindo que desenvolvedores criem aplicativos web rapidamente e facilmente. Neste artigo, abordaremos o que é o Flask, suas principais características, os benefícios de sua API simples, sua flexibilidade em suportar extensões de terceiros, as extensões Flask mais comuns e quando é e não é uma boa hora para usar o Flask.

Principais Considerações

O que é Flask?

Flask é um microframework web escrito em Python usado para desenvolver aplicativos web. Ele é construído com uma filosofia simples de manter as coisas simples e leves, fornecendo aos desenvolvedores apenas as ferramentas mais importantes necessárias para construir aplicativos web sem complexidade desnecessária.

Ele é construído sobre o toolkit WSGI Werkzeug, que fornece a funcionalidade do servidor web necessária para lidar com solicitações e respostas, e o mecanismo de templates Jinja2, que dá a Flask a capacidade de lidar com templates HTML, permitindo que os desenvolvedores criem aplicativos web dinâmicos.

Aqui estão algumas das principais características de Flask que o tornam um ótimo framework para trabalhar:

• Ele possui uma API simples para criar rotas web e lidar com solicitações.
• O mecanismo de modelos Jinja oferece suporte a modelos HTML, permitindo que os desenvolvedores criem páginas da web facilmente.
• É altamente extensível, devido ao seu suporte a extensões de terceiros, permitindo que um desenvolvedor instale extensões de acordo com as necessidades do projeto.
• Ele vem com um servidor de desenvolvimento que facilita a testagem e depuração de aplicativos.

No geral, o Flask fornece uma estrutura poderosa, flexível e, no entanto, simples para a construção de aplicativos web. É uma boa escolha tanto para desenvolvedores web novos quanto experientes e é uma das estruturas web mais populares no ecossistema de desenvolvimento web com Python.

Vantagens do Flask

Vamos agora analisar com mais detalhes algumas das vantagens de usar o Flask no desenvolvimento.

Simplicidade. A filosofia de design do Flask enfatiza a simplicidade, o que facilita para desenvolvedores de qualquer nível entenderem e utilizarem. Isso também significa que os desenvolvedores têm uma curva de aprendizado muito reduzida, já que precisam aprender apenas alguns conceitos e APIs para começar a construir aplicativos web.

Flexibilidade. A natureza micro do Flask — fornecendo apenas os recursos essenciais de uma estrutura web — dá aos desenvolvedores o poder de personalizar e estender conforme necessário, usando extensões do Flask ou bibliotecas de terceiros.

Documentação. A documentação do Flask é muito abrangente, com boa cobertura de tópicos básicos a avançados, facilitando muito para os desenvolvedores aprenderem a usar a estrutura.

Compatibilidade. O Flask é compatível com uma ampla gama de versões do Python, o que facilita seu uso com bases de código Python existentes. Também oferece suporte a vários servidores web, o que facilita sua implantação em uma variedade de plataformas de hospedagem.

Desenvolvimento rápido. A simplicidade e a flexibilidade do Flask reduzem o boilerplate necessário para configurar um aplicativo, permitindo que os desenvolvedores comecem rapidamente.

Por toda a web, o Flask é usado de muitas maneiras interessantes. Alguns exemplos notáveis são:

• PgAdmin. A interface administrativa do Postgres funciona em uma instância do Flask, fornecendo aos desenvolvedores uma interface onde podem gerenciar suas bases de dados Postgres.
• Twilio. Esta é uma plataforma de comunicação que usa o Flask em várias de suas APIs.
• Pinterest. Este aplicativo de compartilhamento de fotos usa o Flask na pilha de desenvolvimento web, permitindo que sua equipe crie facilmente alguns recursos e integrações personalizadas.

Quando Usar o Flask

A simplicidade e a facilidade de uso do Flask o tornam uma excelente escolha para uma ampla gama de projetos web:

• Prototipagem. Sua facilidade de uso e flexibilidade o tornam uma excelente escolha para criar rapidamente protótipos, permitindo que os desenvolvedores construam e testem novos recursos rapidamente.
• Criando APIs RESTful. Sua própria API simples facilita a criação e manipulação de solicitações HTTP.
• Aplicativos de comércio eletrônico. Funciona bem para construir mercados online e plataformas de comércio eletrônico.
• Finanças. É útil para criar aplicativos financeiros, com gerenciamento de contas, processamento de transações e rastreamento de investimentos.
• IA. Oferece uma maneira útil e direta de criar e implantar modelos de treinamento de IA.

Quando Não Usar Flask

Embora Flask seja um ótimo framework e tenha várias vantagens e recursos excelentes, há situações em que esses recursos funcionam contra ele. Vamos explorar alguns dos projetos que se adequam melhor a outros tipos de frameworks.

Projetos que exigem funcionalidades internas. Como microframework, Flask fornece apenas os elementos essenciais necessários para criar um aplicativo web. Se um projeto exigir, por exemplo, uma interface de administração, autenticação ou um ORM, então Django é uma opção melhor.

Projetos com requisitos de segurança rigorosos. Como Flask é um framework flexível, temos que confiar em extensões de terceiros para implementar algum nível de segurança em nossos aplicativos. Embora isso certamente funcione, é melhor confiar em um framework mais testado em batalha que adota uma abordagem mais segura, como Tornado ou Twisted.

Projetos que impõem algum padrão de codificação. Devido à flexibilidade de Flask, o desenvolvimento de aplicativos nele deixa os desenvolvedores a fazerem aplicativos da maneira que desejarem. No entanto, frameworks como Django garantem que os desenvolvedores sigam uma convenção particular, o que significa que os desenvolvedores podem passar de um projeto para outro facilmente.

Configurando um Ambiente de Desenvolvimento Flask

Vamos agora ver como começar com o Flask, desde a configuração do ambiente de desenvolvimento, a instalação, até a criação de um aplicativo mínimo.

Pré-requisitos

Python deve estar instalado na máquina de desenvolvimento. Aqui estão instruções para isso (embora já possamos ter instalado).

Criar um Ambiente Virtual

A virtual environment is an isolated Python environment where we can install packages for a given project without affecting the global Python installation. (Here’s further discussion about why virtual environments are useful.) There are different packages for creating virtual environments in Python, such as virtualenv, venv, or Conda.

Neste artigo, usaremos virtualenv. Podemos instalá-lo com o seguinte comando:

pip install virtualenv

Após a instalação de virtualenv, podemos criar um diretório onde nosso aplicativo Flask residirá. Podemos chamar o diretório como quisermos, exceto Flask, pois isso causará conflitos. Chamaremos o nosso de flask_intro:

mkdir flask_intro

Em seguida, altere para esse diretório para que possamos começar a usá-lo:

cd flask_intro

Nesse diretório, agora vamos criar nosso ambiente virtual, usando o seguinte comando:

virtualenv myenv

O comando acima cria um ambiente virtual e o chama de myenv. Vamos ativá-lo para que possamos instalar o Flask nele. Para ativar o ambiente virtual no Linux ou macOS, use o seguinte comando:

. myenv/bin/activate

No Windows, use este comando:

. myenv\Scripts\activate

Uma vez que nosso ambiente virtual tenha sido ativado, ele mostrará o nome do ambiente virtual no prompt do shell, semelhante ao resultado abaixo:

(myenv)/~(path to your project directory)$

Dentro do nosso ambiente virtual ativado, podemos prosseguir com a instalação do Flask, usando o seguinte comando:

pip install Flask

Após a instalação do Flask, vamos criar um aplicativo mínimo. Vamos criar um módulo que conterá nosso aplicativo Flask. Para simplificar, vamos chamá-lo de hello.py. No Linux ou macOS, podemos usar o seguinte comando para criar o arquivo em nosso diretório flask_intro:

touch hello.py

O comando acima cria um arquivo chamado hello.py. Também poderíamos usar um ambiente de desenvolvimento para criar o arquivo. Uma vez criado, insira o código abaixo nele e salve:

# hello.py
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
    return 'Hello, World!'

No código acima, importamos a classe Flask do módulo flask, depois criamos uma instância de Flask que chamamos de app e passamos a variável __name__.

Em seguida, temos o decorador de rota @app.route(“\”), o que significa que a função hello_world() será acionada quando alguém visitar a rota raiz do nosso aplicativo uma vez que ele seja executado.

Existem várias maneiras de executar o aplicativo, então vamos ver algumas delas. A primeira maneira é fornecer ao comando flask uma série de argumentos: --app, depois o nome do módulo que contém nosso aplicativo Flask, e depois run. Veja abaixo:

flask –app <the name of your module> run

Usando o exemplo acima para executar nosso aplicativo de amostra:

flask –app hello run

Isso executará nosso aplicativo no porto padrão 5000, portanto, o aplicativo estará disponível em http://localhost:5000/ ou em http://127.0.0.1:5000/. Se quisermos que o aplicativo esteja disponível em um porto diferente, podemos especificar o porto usando a opção -p ou --port. Por exemplo:

flask --app hello run --port=8080

Isso executará o servidor no porto 8080. Outra maneira de executar o aplicativo é apenas usando os comandos flask run. No entanto, para fazermos isso, precisamos informar ao Flask o nome do módulo que conterá a instância do Flask, e fazemos isso definindo a variável de ambiente FLASK_APP. Então, no nosso caso, o aplicativo Flask está contido em um arquivo chamado hello.py. Podemos configurá-lo desta maneira:

export FLASK_APP=hello

Agora que definimos a variável de ambiente FLASK_APP, podemos executar o servidor de desenvolvimento assim:

flask run

Com esse código, agora temos um aplicativo web em execução. Isso demonstra a filosofia central do Flask: não precisamos de muito código repetitivo para começar. No entanto, o aplicativo que configuramos acima não é muito funcional ou útil, pois apenas renderiza a string “Hello World!” em nossa página web. Para fazer algo mais útil, podemos recorrer a templates. Vamos ver como lidar com eles a seguir.

Templates do Flask

Templates do Flask são uma maneira de criar páginas web dinâmicas que podem exibir conteúdo diferente com base em vários fatores, como dados de um banco de dados ou entrada do usuário. Os templates no Flask são uma combinação de HTML e espaços reservados especiais chamados variáveis de template que são substituídos por valores reais em tempo de execução.

Os templates são armazenados no diretório templates. Portanto, para usar templates, precisamos importar o método render_template() de flask. O método render_template() recebe um nome de template e quaisquer dados opcionais que precisam ser passados para o template.

Vejamos um exemplo de uma função que usa um template para renderizar uma página da web:

# index.py
from flask import Flask, render_template
app = Flask(__name__)
@app.route('/')
def index():
    title = 'Welcome to my website!'
    message = 'This is an example of using Flask templates.'
    return render_template('index.html', title=title, message=message)

No exemplo acima, temos uma função de visualização — index() — que está vinculada à URL raiz (“/”) pelo decorador @app.route(). A função tem duas variáveis, title e message. Finalmente, passamos o template index.html para o render_template(), juntamente com as variáveis title e message.

Para que o código acima funcione, precisamos ter um template index.html residindo em um diretório de templates. Portanto, o template será algo assim:

# index.html
<!doctype html>
<html>
<head>
    <title>{{ title }}</title>
</head>
<body>
    <h1>{{ title }}</h1>
    <p>{{ message }}</p>
</body>
</html>

No arquivo index.html, os espaços reservados {{title}} e {{ message }} são substituídos pelos valores passados para o template no método render_template().

Os templates também podem incluir lógica mais complexa, como instruções if e loops for, o que permite a geração de páginas mais dinâmicas.

Portanto, os templates no Flask oferecem aos desenvolvedores uma opção muito poderosa para criar páginas da web dinâmicas ricas em informações geradas pelo usuário.

Roteamento Flask

A maioria das aplicações web terá mais de uma URL, portanto, precisamos de uma maneira de saber qual função lida com qual URL. No Flask, essa mapeamento é conhecido como roteamento — o processo de vincular ou mapear URLs para funções de visualização. Vincular URLs a funções de visualização permite que o aplicativo manipule diferentes tipos de solicitações, como GET, POST, PUT, DELETE e mais. Também permite que o aplicativo manipule múltiplas solicitações de diferentes clientes.

Para configurar rotas no Flask, usamos o route() decorador. O decorador vincula uma URL a uma função de visualização — então, quando um usuário visita uma URL que existe em nossa aplicação, Flask aciona a função de visualização associada para lidar com a solicitação.

Vejamos um exemplo:

# hello.py
from flask import Flask, render_template

app = Flask(__name__)

@app.route("/about")
def about():
    return "This is the about page"

No exemplo acima, definimos uma URL sobre (/about). Quando a aplicação recebe uma solicitação para a URL about, Flask chama a função about(), que retorna a string “Esta é a página sobre”.

Até agora, embora esses exemplos retornem páginas diferentes, todos eles usam apenas a solicitação HTTP GET. Para poder lidar com qualquer solicitação específica, podemos especificar o método HTTP como um argumento opcional para o route() decorador.

Vejamos um exemplo de uma solicitação PUT:

from flask import Flask, request

app = Flask(__name__)

@app.route('/users/<int:user_id>', methods=['PUT'])
def update_user(user_id):
    # obter dados do usuário do corpo da solicitação
    data = request.get_json()
    # fazer algo com os dados do usuário, como atualizar o usuário no banco de dados
    # ...
    # retornar uma resposta indicando sucesso ou falha
    return {'message': f'User {user_id} updated successfully'}, 200

Neste exemplo, definimos uma rota que lida com uma solicitação PUT para atualizar os detalhes do usuário com base em seu user_id. Usamos <int:user_id> na rota para indicar que o ID do usuário deve ser um inteiro.

Na função update_user(), obtemos os dados do usuário do corpo da solicitação usando o método request.get_json(). Fazemos algo com os dados do usuário, como atualizar o usuário no banco de dados, e então retornamos uma resposta indicando sucesso ou falha, juntamente com um código de status HTTP (um 200 neste caso para indicar sucesso).

No geral, o roteamento permite que o Flask possa lidar com diferentes tipos de solicitações e permita que nosso aplicativo lide e atue de forma diferente com base na URL que um usuário visita.

Formulários e Validação em Flask

Além de exibir dados para os usuários, os templates Flask também podem receber entrada de usuários para processamentos adicionais ou armazenamento. Para isso, o Flask fornece suporte integrado para processar formulários HTML e lidar com a entrada do usuário. Os formulários Flask são baseados na biblioteca WTForms, que fornece uma maneira flexível e poderosa de lidar com dados de formulário e realizar validações. No entanto, a biblioteca não faz parte da instalação padrão do Flask, então precisamos instalá-la usando o seguinte comando:

pip install WTForms

Uma vez que instalamos o WTForms, para utilizar formulários no Flask precisamos definir uma classe de formulário que herdará de flask_wtf.FlaskForm. Essa classe conterá os campos que estarão no formulário e quaisquer regras de validação que devem ser aplicadas a eles.

Vejamos um exemplo de um formulário de login:

# forms.py
from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField
from wtforms.validators import DataRequired, Email, Length

class LoginForm(FlaskForm):
    email = StringField('Email', validators=[DataRequired(), Email()])
    password = PasswordField('Password', validators=[DataRequired(), Length(min=6)])
    submit = SubmitField('Log In')

No exemplo acima, definimos um formulário de login com dois campos — email e password — e um botão de submit. Também temos um argumento validators que é usado para especificar regras de validação para cada campo. Por exemplo, nesse caso exigimos que o campo email contenha um endereço de email válido e o campo password contenha uma senha de pelo menos seis caracteres.

Uma vez que definimos a classe do formulário, podemos usá-la na função de visualização de login para renderizar o formulário e processar os dados do formulário enviados pelo usuário. Vejamos um exemplo da função de visualização:

# views.py
from flask import render_template, request
from .forms import LoginForm

@app.route('/login', methods=['GET', 'POST'])
def login():
    form = LoginForm()
    if form.validate_on_submit():
        email = form.email.data
        password = form.password.data
        # fazer algo com os dados do formulário
    return render_template('login.html', form=form)

No exemplo acima, temos uma visualização login que aceita dois métodos HTTP (GET e POST), então quando os usuários acessam a URL a partir de um navegador o LoginForm é renderizado como um formulário HTML usando o método render_template, e quando um usuário submete o formulário verificamos se o formulário é válido usando o método validate_on_submit. Se o formulário for válido, acessamos o email e a senha.

O formulário login.html poderia se parecer com algo assim:

# login.html
<h1>Login</h1>
<form method="POST">
  {{ form.csrf_token }}
  <div>
    {{ form.email.label }} {{ form.email() }}
    {% for error in form.email.errors %}
    <span style="color: red;">[{{ error }}]</span>
    {% endfor %}
  </div>
  <div>
    {{ form.password.label }} {{ form.password() }}
    {% for error in form.password.errors %}
      <span style="color: red;">[{{ error }}]</span>
    {% endfor %}
  </div>
  {{ form.submit() }}
</form>

O template acima renderizará os campos email e password, juntamente com seus rótulos, e um botão de envio com o texto “Login”. O campo form.csrf_token é incluído para prevenir ataques de falsificação de solicitação entre sites (CSRF). Os loops {% for %} são utilizados para exibir quaisquer erros de validação que possam ocorrer.

Ao utilizar formulários Flask, temos uma maneira poderosa de lidar com a entrada do usuário e poderemos validar os dados que eles inserirem.

Extensões Flask

Como vimos, Flask é um microframework que inclui apenas as partes mais importantes necessárias para criar um aplicativo web. No entanto, se precisarmos adicionar funcionalidades que não são oferecidas nativamente pelo Flask, precisamos adicionar pacotes à instalação. As extensões Flask são a maneira de fornecer essa funcionalidade adicional. Podemos simplesmente instalar o pacote que precisamos. Existem muitas extensões criadas pela comunidade Flask.

Aqui estão algumas das mais populares:

• Flask-SQLAlchemy: fornece integração com a toolkit SQLAlchemy, facilitando a interação com bancos de dados.
• Flask-Login: fornece autenticação de usuário e gerenciamento de sessão para Flask.
• Flask-Mail: fornece uma interface simples para enviar emails a partir do Flask.

Existem centenas de extensões criadas pela comunidade Flask para lidar com diferentes funcionalidades. Usar as extensões geralmente é direto. Primeiro, precisamos instalar a extensão que desejamos usando pip.

Vamos ver um exemplo de uso do Flask-SQLAlchemy. Primeiro, precisamos instalá-lo:

pip install flask-sqlalchemy

Em seguida, precisamos configurá-lo. Por exemplo:

# sqlalchemy_example.py
from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///example.db'
db = SQLAlchemy(app)

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)

    def __repr__(self):
        return '<User %r>' % self.username

No exemplo acima, temos um modelo User com um campo username e email. Também configuramos SQLALCHEMY_DATABASE_URI, indicando que estamos usando um banco de dados SQLite localizado em example.db. Com isso definido, agora temos acesso ao objeto db que nos permite interagir com o banco de dados. Por exemplo, poderíamos criar um novo usuário e adicioná-lo ao banco de dados, da seguinte forma:

#views.py 
from app import db, User

user = User(username='john', email='[email protected]')
db.session.add(user)
db.session.commit()

Com extensões do Flask, nosso aplicativo é capaz de ter mais funcionalidades do que normalmente teria com a implementação central do Flask.

Conclusão

Neste artigo, apresentamos o Flask, um framework web leve e flexível para Python. Discutimos as vantagens de usar o Flask para o desenvolvimento web, incluindo sua simplicidade, flexibilidade e facilidade de uso. Também abordamos como configurar um ambiente de desenvolvimento, criar rotas, usar templates, lidar com formulários e usar extensões como Flask-SQLAlchemy.

Para resumir, o Flask é uma ótima escolha para construir aplicativos web de qualquer tamanho, desde projetos pessoais até aplicativos comerciais de grande escala. É fácil de aprender e usar, mas também oferece recursos avançados por meio de suas muitas extensões.

Se você estiver interessado em saber mais sobre o Flask, aqui estão alguns recursos adicionais:

• Documentação do Flask
• Flask Mega-Tutorial, de Miguel Grinberg
• Desenvolvimento Web com Flask, de Miguel Grinberg
• A simple Flask app tutorial
• Tutoriais de Flask na Real Python

Se você deseja aprender mais sobre Django e Flask e seus melhores casos de uso, confira Desenvolvimento Web com Python usando Django e Flask.

Perguntas Frequentes sobre Flask, o Framework Python