Os 5 principais frameworks da Web assíncronos para Python

A programação assíncrona é um cidadão de primeira classe em Python agora. Se você é um desenvolvedor web, existem frameworks incríveis que você pode escolher!

Até o momento, assíncrono não é mais apenas um chavão na comunidade Python. Com o lançamento de seu assíncrono biblioteca na versão 3.5, Python reconheceu o impacto do Node.js no desenvolvimento web e introduziu duas novas palavras-chave na linguagem — async e await. Isso foi um grande negócio porque a linguagem Python é extremamente cautelosa em expandir a sintaxe central, a menos que haja uma necessidade urgente, o que apenas indica o quão fundamentalmente importante os desenvolvedores do Python consideraram os recursos assíncronos.

Como resultado, as comportas da programação assíncrona foram abertas: bibliotecas novas e antigas começaram a usar o recurso de corrotinas, frameworks assíncronos explodiram em popularidade e novos ainda estão sendo escritos hoje. Desempenho igual ou melhor que o do Node.js não é inédito e, a menos que seus padrões de carregamento envolvam muitas tarefas de CPU pesada, não há razão para que você não possa fazer alguns milhares de solicitações por segundo.

Mas chega de motivação!

Vamos examinar o cenário atual do Python e conferir alguns dos principais frameworks assíncronos.

Tornado

Surpreendentemente, Tornado não é uma estrutura nova. Seu lançamento inicial foi em 2009 (exatamente dez anos atrás, no momento da escrita) e, desde então, seu foco tem sido fornecer programação assíncrona sólida com alta simultaneidade.

Tornado não é um framework web fundamentalmente. É uma coleção de módulos assíncronos, que também são usados ​​para construir o módulo do framework web. Mais especificamente, esses módulos são:

• Corrotinas e outras primitivas (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 produzir os módulos finais da estrutura: tornado.web, tornado.routing, tornado.template, etc.

import tornado.ioloop
import tornado.web

class MainHandler(tornado.web.RequestHandler):
    def get(self):
        self.write("Hello, world")

def make_app():
    return tornado.web.Application([
        (r"/", MainHandler),
    ])

if __name__ == "__main__":
    app = make_app()
    app.listen(8888)
    tornado.ioloop.IOLoop.current().start()

O Tornado tem seguidores fortes e comprometidos na comunidade Python e é usado por arquitetos experientes para construir sistemas altamente capazes. É uma estrutura que há muito tem a resposta para os problemas de simultaneidade, mas talvez não tenha se tornado popular, pois não suporta o padrão WSGI e foi muito aceita (lembre-se de que a maior parte das bibliotecas Python ainda são síncronas ).

Sanic

Sanic é um framework “moderno” no verdadeiro sentido da palavra: ele não suporta a versão Python abaixo de 3.6, suporta a sintaxe simples e universal async/await pronta para uso e, como resultado, não faz você ler cargas de documentação e mantenha os casos extremos em mente antes de escrever seu primeiro manipulador HTTP.

Como resultado, a sintaxe resultante é bastante agradável (na minha opinião, pelo menos); assemelha-se ao código que você escreveria com qualquer outro microframework (Flask, CherryPy, por exemplo) com apenas alguns assíncronos polvilhados:

from sanic import Sanic
from sanic.response import json

app = Sanic()

@app.route("/")
async def test(request):
    return json({"hello": "world"})

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000)

Sanic é sem dúvida a estrutura assíncrona mais popular e amada no mundo Python. Ele tem quase todos os recursos que você deseja para seus projetos – roteamento, middleware, cookies, versionamento, blueprints, visualizações baseadas em classes, arquivos estáticos, streaming, soquetes, etc. – e o que ele não oferece imediatamente — modelagem, suporte a banco de dados, E/S de arquivo, filas — podem ser adicionados, pois há bibliotecas assíncronas suficientes para isso a partir de hoje.

Vibora

Vibora é um primo próximo do Sanic, exceto que está determinado a se tornar o servidor web Python mais rápido do mercado. De fato, a primeira visita de seu site o recebe com uma comparação de estrutura:

Como você pode ver, o Vibora afirma ser várias vezes mais rápido que os frameworks clássicos e mais que duas vezes mais rápido que o Sanic, seu concorrente mais próximo. É claro que os benchmarks devem ser tomados com um grão de sal. 🙂

Embora em sintaxe e recursos, o Vibora seja comparável ao Sanic (ou talvez até um pouco melhor, pois agrupa bibliotecas populares e coisas como templates estão disponíveis imediatamente), eu consideraria o Sanic mais maduro, pois existe há mais tempo e tem uma comunidade maior.

from vibora import Vibora, JsonResponse

app = Vibora()

@app.route('/')
async def home():
    return JsonResponse({'hello': 'world'})

if __name__ == '__main__':
    app.run(host="0.0.0.0", port=8000)

Se você é um viciado em performance, porém, Vibora pode flutuar seu barco. Dito isso, no momento da escrita, o Vibora está fazendo uma reescrita completa para se tornar ainda mais rápido, e o link para sua versão de desempenho diz que está em “desenvolvimento pesado”. Vai ser uma decepção para aqueles que pegaram o Vibora mais cedo e em breve devem enfrentar mudanças importantes, mas ei, é cedo no mundo assíncrono do Python e ninguém espera que as coisas sejam estáveis.

Quarto

Se você gosta de desenvolver em Flask, mas lamenta a falta de suporte assíncrono, você vai gostar Quarto muito.

Quart está em conformidade com o ASGI padrão, que é um sucessor do famoso padrão WSGI e oferece suporte assíncrono. O interessante sobre o Quart é que ele não é apenas semelhante ao Flask, mas também é compatível com a API do Flask! O autor dessa estrutura queria preservar a sensação do Flask e apenas adicionar suporte assíncrono, WebSockets e HTTP 2 a ele. Como resultado, você pode aprender Quart diretamente da documentação do Flask, apenas tendo em mente que as funções no Quart são assíncronas.

from quart import Quart

app = Quart(__name__)

@app.route('/')
async def hello():
    return 'hello'

app.run()

Parece (quase) exatamente como o Flask, não é?!

Como o Quart é uma evolução do Flask, todos os recursos dentro do Flask estão disponíveis: roteamento, middleware, sessões, modelos, blueprints e assim por diante. Na verdade, você pode até usar extensões do Flask diretamente dentro do Quart. Um problema é que o Python 3.7+ é suportado apenas, mas, se você não estiver executando a versão mais recente do Python, talvez o async não seja o caminho certo. 🙂

A documentação é realmente necessária se você não tiver experiência anterior com o Flask, mas posso recomendar o Quart, pois provavelmente é o único framework assíncrono que se aproxima do lançamento 1.0 em breve.

FastAPI

O último (mas mais impressionante) framework desta lista é FastAPI. Não, não é uma estrutura somente de API; na verdade, FastAPI parece ser a estrutura mais rica em recursos e documentação que encontrei ao pesquisar estruturas Python assíncronas.

É interessante notar que o autor do framework estudou vários outros frameworks em profundidade, desde os contemporâneos como o Django até os modernos como o Sanic, além de analisar tecnologias no NestJS (um framework web Node.js, Typescript). Sua filosofia de desenvolvimento e extensas comparações podem ser lidas aqui.

A sintaxe é bastante agradável; pode-se até argumentar que é muito mais agradável do que os outros frameworks que encontramos:

rom fastapi import FastAPI

app = FastAPI()

@app.get("/users/me")
async def read_user_me():
    return {"user_id": "the current user"}

@app.get("/users/{user_id}")
async def read_user(user_id: str):
    return {"user_id": user_id}

E agora, a lista de recursos matadores que fazem o FastAPI ofuscar outros frameworks:

Geração automática de documentos de API: assim que seus endpoints forem gravados, você poderá brincar com a API usando uma interface de usuário compatível com os padrões. SwaggerUI, ReDoc e outros são suportados.

A estrutura também faz a documentação automática do modelo de dados com o JSON Schema.

Desenvolvimento moderno: Sim, a palavra “moderno” é muito usada, mas achei o FastAPI realmente para falar. Injeção de dependência e dica de tipo são cidadãos de primeira classe, reforçando não apenas bons princípios de codificação, mas evitando bugs e confusão a longo prazo.

Documentação extensa: eu não sei você, mas eu sou um otário total por boa documentação. E nesta área, o FastAPI ganha de longe. Tem páginas e mais páginas de documentos explicando quase todas as sutilezas e “cuidado!” momentos para desenvolvedores de todos os níveis. Eu sinto um claro “coração e alma” nos documentos aqui, e a única comparação que posso encontrar são os documentos do Django (sim, os documentos FastAPI são tão bons!).

Além do básico: FastAPI tem suporte para WebSockets, Streaming, bem como GraphQL, além de contar com todos os auxiliares tradicionais como CORS, sessões, cookies, etc.

E o desempenho? Bem, o FastAPI é construído na incrível biblioteca Starlette, resultando em um desempenho que corresponde ao Node e, em alguns casos, até mesmo ao Go! Em suma, eu realmente tenho a sensação de que FastAPI vai correr à frente como o principal framework assíncrono para Python.

Conclusão

Muita coisa está acontecendo no cenário assíncrono do Python nos dias de hoje. Novos frameworks estão surgindo, os antigos estão sendo reescritos e as bibliotecas estão sendo desenvolvidas para corresponder ao comportamento assíncrono. Embora o Python tenha suporte interno para um loop de eventos e seja possível tornar partes do seu aplicativo assíncronas, você pode optar por ir all-in e construir em uma das estruturas aqui. Apenas certifique-se de manter o longo prazo em mente: várias das estruturas assíncronas do Python estão em estágios iniciais e estão sendo desenvolvidas rapidamente, o que prejudicará seu processo de desenvolvimento e aumentará os custos de negócios. Cuidado é fundamental!

Mas tudo dito e feito; O Python está pronto para produção para fornecer desempenho leve quando se trata de estruturas da Web. Se há tanto tempo você pensa em migrar para o Node, agora não precisa mais! 🙂

Parece legal? Mestre Python hoje!