A programação assíncrona tornou-se um componente essencial no Python. Para desenvolvedores web, a variedade de frameworks disponíveis é notável e promissora!
A era em que a assincronicidade era apenas um conceito vago no universo Python ficou para trás. Com a introdução da biblioteca asyncio na versão 3.5, o Python sinalizou o impacto do Node.js no desenvolvimento web, incorporando as palavras-chave async e await. Essa inclusão foi um marco significativo, dada a postura conservadora do Python em relação à expansão da sua sintaxe central, indicando a importância fundamental que a comunidade de desenvolvimento Python atribuiu aos recursos assíncronos.
Consequentemente, abriu-se um novo horizonte para a programação assíncrona. Bibliotecas, tanto novas quanto estabelecidas, começaram a adotar corrotinas, e frameworks assíncronos ganharam popularidade, com novos surgindo constantemente. É agora possível alcançar um desempenho igual ou superior ao do Node.js, e, desde que a sua carga de trabalho não seja excessivamente dependente de tarefas intensivas de CPU, não há razão para não conseguir gerir milhares de solicitações por segundo.
Mas, chega de motivação, vamos aprofundar!
Vamos agora explorar o cenário atual do Python, com foco em alguns dos frameworks assíncronos mais relevantes.
Tornado
Surpreendentemente, o Tornado não é um framework recente. O seu lançamento inicial remonta a 2009 (uma década atrás, na altura em que este artigo foi escrito), tendo desde então se concentrado em fornecer uma programação assíncrona robusta e de alta simultaneidade.
O Tornado não é exclusivamente um framework web. É, na verdade, uma coleção de módulos assíncronos, também utilizados para criar o módulo do framework web. Mais precisamente, estes módulos são:
- Corrotinas e primitivas relacionadas (tornado.gen, tornado.locks, tornado.queues, etc.)
- Módulos de rede (tornado.ioloop, tornado.iostream, etc.)
- Servidores e clientes assíncronos (tornado.httpserver, tornado.httpclient, etc.)
Estes foram combinados para formar os módulos finais do framework: tornado.web, tornado.routing, tornado.template, entre outros.
import tornado.ioloop
import tornado.web
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.write("Olá, mundo")
def criar_app():
return tornado.web.Application([
(r"/", MainHandler),
])
if __name__ == "__main__":
app = criar_app()
app.listen(8888)
tornado.ioloop.IOLoop.current().start()
O Tornado goza de uma base de seguidores leal na comunidade Python e é usado por arquitetos experientes para construir sistemas altamente capazes. Apesar de ser uma estrutura que há muito oferece soluções para problemas de simultaneidade, a sua adoção generalizada pode ter sido dificultada pela falta de suporte ao padrão WSGI, que prevalecia na altura (lembre-se que a maioria das bibliotecas Python são ainda síncronas).
Sanic
O Sanic é um framework “moderno” no sentido estrito do termo: ele requer o Python 3.6 ou superior, suporta a sintaxe async/await de forma nativa e, como tal, dispensa leituras extensas de documentação e a necessidade de ter casos extremos em mente antes de criar o seu primeiro manipulador HTTP.
A sintaxe resultante é bastante intuitiva (na minha opinião, pelo menos); assemelha-se ao código que se escreveria com qualquer outro microframework (como Flask ou CherryPy), com apenas alguns elementos assíncronos adicionados:
from sanic import Sanic
from sanic.response import json
app = Sanic()
@app.route("/")
async def teste(request):
return json({"mensagem": "Olá, mundo"})
if __name__ == "__main__":
app.run(host="0.0.0.0", port=8000)
O Sanic é, sem dúvida, o framework assíncrono mais popular e apreciado no mundo Python. Ele oferece a maioria dos recursos que poderá precisar nos seus projetos – roteamento, middleware, cookies, versionamento, blueprints, visualizações baseadas em classes, arquivos estáticos, streaming, sockets, etc. E, embora não forneça diretamente modelagem, suporte para bases de dados, operações de I/O de ficheiros ou filas, estes podem ser adicionados através de diversas bibliotecas assíncronas disponíveis.
Vibora
O Vibora é um parente próximo do Sanic, com o objetivo de se tornar o servidor web Python mais rápido do mercado. Aliás, a primeira visita ao seu site apresenta uma comparação de desempenho:
Como se pode verificar, o Vibora afirma ser várias vezes mais rápido do que os frameworks clássicos, e mais do que o dobro da velocidade do Sanic, o seu concorrente mais direto. No entanto, os resultados de benchmarks devem ser interpretados com cautela. 🙂
Embora a sintaxe e as funcionalidades do Vibora sejam comparáveis ao Sanic (ou talvez até um pouco melhores, dado que inclui bibliotecas populares e funcionalidades como templates), o Sanic parece mais maduro, dada a sua existência mais longa e uma comunidade maior.
from vibora import Vibora, JsonResponse
app = Vibora()
@app.route('/')
async def home():
return JsonResponse({'mensagem': 'Olá, mundo'})
if __name__ == '__main__':
app.run(host="0.0.0.0", port=8000)
Se você prioriza o desempenho acima de tudo, o Vibora pode ser o ideal. Dito isto, no momento em que este artigo foi escrito, o Vibora está a ser totalmente reescrito para melhorar ainda mais a sua velocidade, e o link para a sua versão de desempenho indica que está em “desenvolvimento ativo”. Isto pode desapontar quem já adotou o Vibora, uma vez que poderá haver alterações substanciais em breve, mas esta é a realidade do mundo assíncrono do Python, onde a estabilidade não é ainda uma garantia.
Quart
Se é fã do desenvolvimento com Flask, mas lamenta a falta de suporte assíncrono, o Quart será do seu agrado.
O Quart é compatível com o padrão ASGI, um sucessor do padrão WSGI que introduz suporte assíncrono. O que torna o Quart especialmente interessante é que, para além da sua semelhança com o Flask, a sua API é também compatível com a do Flask! O autor deste framework tinha como objetivo preservar a experiência do Flask, adicionando apenas suporte assíncrono, WebSockets e HTTP 2. Assim, pode aprender o Quart recorrendo à documentação do Flask, tendo apenas em consideração que as funções no Quart são assíncronas.
from quart import Quart
app = Quart(__name__)
@app.route('/')
async def hello():
return 'Olá'
app.run()
É (quase) idêntico ao Flask, não é?
Sendo o Quart uma evolução do Flask, todas as funcionalidades do Flask estão disponíveis: roteamento, middleware, sessões, templates, blueprints e assim por diante. De facto, pode até utilizar extensões do Flask diretamente no Quart. Um possível inconveniente é o suporte apenas para Python 3.7+, mas se não estiver a utilizar a versão mais recente do Python, talvez a assincronicidade não seja a melhor opção para si. 🙂
A documentação é essencial caso não tenha experiência com o Flask, mas posso recomendar o Quart, pois é provavelmente o único framework assíncrono que está perto de atingir a versão 1.0.
FastAPI
O último (mas não menos impressionante) framework desta lista é o FastAPI. Não se trata apenas de um framework para APIs; de facto, o FastAPI parece ser o framework mais rico em funcionalidades e documentação que encontrei ao pesquisar frameworks Python assíncronos.
É relevante notar que o autor do framework estudou vários outros frameworks em profundidade, desde os contemporâneos como o Django até aos mais recentes como o Sanic, analisando também tecnologias do NestJS (um framework web Node.js, Typescript). A sua filosofia de desenvolvimento e comparações detalhadas podem ser encontradas aqui.
A sintaxe é bastante agradável e, alguns diriam, mais intuitiva do que outros frameworks apresentados:
from fastapi import FastAPI
app = FastAPI()
@app.get("/users/me")
async def ler_utilizador_atual():
return {"utilizador_id": "o utilizador atual"}
@app.get("/users/{user_id}")
async def ler_utilizador(user_id: str):
return {"utilizador_id": user_id}
E agora, uma lista de funcionalidades que fazem o FastAPI sobressair-se:
Geração automática de documentação de API: assim que os endpoints são criados, é possível interagir com a API através de interfaces de utilizador compatíveis com padrões. São suportados o SwaggerUI, ReDoc e outros.
O framework também gera automaticamente documentação do modelo de dados com JSON Schema.
Desenvolvimento moderno: embora a palavra “moderno” seja utilizada frequentemente, o FastAPI faz jus a esse termo. A injeção de dependência e a tipagem estática são elementos de primeira classe, promovendo não só boas práticas de programação, como também evitando bugs e confusões a longo prazo.
Documentação detalhada: sou um grande fã de boa documentação. E nesse campo, o FastAPI é imbatível. Há páginas e páginas de documentação que explicam praticamente todas as nuances e potenciais problemas para programadores de todos os níveis. É notório o cuidado e o esforço dedicado à documentação, comparável apenas aos documentos do Django (sim, os documentos do FastAPI são assim tão bons!).
Para além do básico: o FastAPI tem suporte para WebSockets, Streaming e GraphQL, para além de oferecer os auxiliares tradicionais como CORS, sessões, cookies, etc.
E quanto ao desempenho? O FastAPI é construído com base na biblioteca Starlette, resultando em desempenho equivalente ao do Node e, em alguns casos, até superior ao do Go! Em suma, tenho a sensação de que o FastAPI se tornará o principal framework assíncrono para Python.
Conclusão
O cenário assíncrono do Python está em plena transformação. Surgem novos frameworks, os antigos estão a ser reescritos e as bibliotecas estão a ser desenvolvidas para se adaptarem ao comportamento assíncrono. Embora o Python ofereça suporte nativo para um loop de eventos e seja possível tornar partes da sua aplicação assíncronas, pode optar por adotar uma das estruturas apresentadas. Mas tenha em mente o longo prazo: muitos frameworks assíncronos do Python estão em fases iniciais de desenvolvimento, o que pode prejudicar o seu processo de desenvolvimento e aumentar os custos. Cautela é fundamental!
Contudo, o Python está pronto para fornecer um desempenho leve em aplicações web. Se estava a ponderar a migração para o Node, talvez já não precise de o fazer! 🙂
Interessado? Domine Python hoje mesmo!