Top 5 Asynkrone Web Frameworks til Python

Asynkron programmering er en førsteklasses borger i Python nu. Hvis du er webudvikler, er der fantastiske rammer, du kan vælge imellem!

I skrivende stund er asynkron ikke længere kun et buzzword i Python-fællesskabet. Med udgivelsen af sin asyncio bibliotek i 3.5-version anerkendte Python virkningen af Node.js på webudvikling og introducerede to nye nøgleord i sproget – asynkron og afvent. Dette var en meget stor sag, fordi Python-sproget er ekstremt forsigtig med at udvide kernesyntaksen, medmindre der er et presserende behov, hvilket kun indikerer, hvor fundamentalt vigtigt Python-udviklerne anså de asynkrone muligheder.

Som et resultat blev sluserne for asynkron programmering åbnet: nye og gamle biblioteker begyndte at gøre brug af coroutines-funktionen, asynkrone rammer eksploderede i popularitet, og nye bliver stadig skrevet i dag. Ydeevne på niveau med eller bedre end Node.js’s er ikke uhørt, og medmindre dine indlæsningsmønstre involverer masser af CPU-tunge opgaver, er der ingen grund til, at du ikke kan lave et par tusinde anmodninger i sekundet.

Men motivation nok!

Lad os undersøge det nuværende Python-landskab og se nogle af de bedste asynkrone rammer.

Indholdsfortegnelse

Tornado

Overraskende nok, Tornado er slet ikke en ny ramme. Dens første udgivelse var i 2009 (præcis ti år siden, i skrivende stund), og siden da har dens fokus været på at levere bundsolid asynkron programmering med høj samtidighed.

Tornado er grundlæggende ikke en webramme. Det er en samling af asynkrone moduler, som også bruges til at bygge webrammemodulet. Mere specifikt er disse moduler:

Coroutiner og andre primitiver (tornado.gen, tornado.locks, tornado.queues osv.)
Netværksmoduler (tornado.ioloop, tornado.iostream osv.)
Asynkrone servere og klienter (tornado.httpserver, tornado.httpclient osv.)

Disse er blevet kombineret for at producere de endelige rammemoduler: tornado.web, tornado.routing, tornado.template osv.

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()

Tornado har en stærk og engageret tilhængerskare i Python-samfundet og bruges af erfarne arkitekter til at bygge meget dygtige systemer. Det er en ramme, der længe har haft svaret på problemerne med samtidighed, men som måske ikke blev mainstream, da den ikke understøtter WSGI-standarden og var for meget af en buy-in (husk, at størstedelen af Python-biblioteker stadig er synkrone ).

Sådan bruger du RSS-feeds

Sanic

Sanic er en “moderne” ramme i ordets egentlige forstand: den understøtter ikke Python-version under 3.6, understøtter den enkle og universelle asynkron/afvent-syntaks ud af boksen og får dig som et resultat ikke til at læse belastninger af dokumentation og husk kantsager i dit sind, før du kan skrive din første HTTP-handler.

Som et resultat er den resulterende syntaks ganske behagelig (efter min mening i det mindste); det ligner kode, du ville skrive med et hvilket som helst andet mikrorammeværk (f.eks. Flask, CherryPy) med kun et par asynkroniseringer drysset ind:

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 er uden tvivl den mest populære og mest elskede async-ramme i Python-verdenen. Det har næsten alle funktioner, du ønsker til dine projekter – routing, middleware, cookies, versionering, tegninger, klassebaserede visninger, statiske filer, streaming, sockets osv. – og hvad det ikke tilbyder lige fra boksen — skabeloner, databaseunderstøttelse, fil I/O, køer — kan tilføjes, da der lige er nok asynkrone biblioteker til disse i dag.

Vibora

Vibora er en nær fætter til Sanic, bortset fra at den er fikseret på at blive den hurtigste Python-webserver derude. Faktisk hilser det allerførste besøg på dens hjemmeside dig med en sammenligning af rammer:

Som du kan se, hævder Vibora at være flere gange hurtigere end de klassiske rammer og er mere end dobbelt så hurtig som Sanic, dens nærmeste konkurrent. Selvfølgelig skal benchmarks tages med et gran salt. 🙂

Selvom Vibora i syntaks og funktioner er sammenlignelig med Sanic (eller måske endda lidt bedre, da den samler populære biblioteker og ting som skabeloner er tilgængelige ud af boksen), ville jeg betragte Sanic som mere moden, da den har eksisteret længere og har et større fællesskab.

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)

Hvis du er en præstationsjunkie, kan Vibora dog flyde din båd. Når det er sagt, er Vibora i skrivende stund under en fuldstændig omskrivning for at blive endnu hurtigere, og den link til dens ydeevneversion siger, at den er under “tung udvikling.” Det vil være et svigt for dem, der hentede Vibora tidligere og snart må stå over for bryderi, men hey, det er tidlige dage i Python async-verdenen, og ingen forventer, at tingene er stabile.

Dette værktøj fortæller dig alt, hvad din browser fortæller websteder om dig

Quart

Hvis du kan lide at udvikle i Flask, men beklager manglen på async support, vil du nyde det Quart en masse.

Quart er i overensstemmelse med ASGI standard, som er en efterfølger til den berømte WSGI-standard og tilbyder async support. Det interessante ved Quart er, at det ikke kun ligner Flask, men faktisk er kompatibelt med Flask API! Forfatteren af denne ramme ønskede at bevare Flask-følelsen og blot tilføje async, WebSockets og HTTP 2-understøttelse til den. Som et resultat kan du lære Quart direkte fra Flask-dokumentationen, bare husk på, at funktioner i Quart er asynkrone.

from quart import Quart

app = Quart(__name__)

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

app.run()

Føles (næsten) præcis som Flask, ikke?!

Da Quart er en udvikling af Flask, er alle funktionerne i Flask tilgængelige: routing, middleware, sessioner, skabeloner, tegninger og så videre. Faktisk kan du endda bruge Flask-udvidelser direkte inde i Quart. En hake er, at Python 3.7+ kun understøttes, men hvis du ikke kører den nyeste version af Python, er asynkronisering måske ikke den rigtige vej. 🙂

Dokumentationen er virkelig efterspurgt, hvis du ikke har tidligere erfaring med Flask, men jeg kan anbefale Quart, da det sandsynligvis er det eneste asynkrone framework, der snart nærmer sig sin 1.0-udgivelse.

FastAPI

Den sidste (men mest imponerende) ramme på denne liste er FastAPI. Nej, det er ikke kun en API-ramme; Faktisk ser FastAPI ud til at være det mest funktionsrige og dokumentationsrige framework, som jeg stødte på, da jeg undersøgte asynkrone Python-frameworks.

Det er interessant at bemærke, at rammeværksforfatteren studerede flere andre rammer i dybden, fra de moderne som Django til moderne som Sanic, såvel som at se på tværs af teknologier i NestJS (en Node.js, Typescript-webramme). Deres udviklingsfilosofi og omfattende sammenligninger kan læses her.

Syntaksen er ganske behagelig; man kan endda argumentere for, at det er meget sjovere end de andre rammer, vi er stødt på:

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}

Og nu er listen over dræbende funktioner, der får FastAPI til at overstråle andre rammer:

Hvordan fjerner du linket til en Call of Duty-konto

Automatisk generering af API-dokumenter: Så snart dine slutpunkter er blevet skrevet, kan du lege med API’et ved hjælp af en standardkompatibel brugergrænseflade. SwaggerUI, ReDoc og andre understøttes.

Frameworket laver også automatisk datamodeldokumentation med JSON Schema.

Moderne udvikling: Ja, ordet “moderne” bliver slynget rundt meget, men jeg fandt, at FastAPI faktisk taler om det. Afhængighedsinjektion og typeantydninger er førsteklasses borgere, der håndhæver ikke kun gode kodningsprincipper, men forhindrer fejl og forvirring i det lange løb.

Omfattende dokumentation: Jeg ved ikke med dig, men jeg er helt vild med god dokumentation. Og på dette område vinder FastAPI hånden ned. Den har sider på sider med dokumenter, der forklarer næsten hver eneste lille finesse og “pas på!” øjeblikke for udviklere på alle niveauer. Jeg fornemmer et klart “hjerte og sjæl” i dokumenterne her, og den eneste sammenligning, jeg kan finde, er Django-dokumenterne (ja, FastAPI-dokumenterne er så gode!).

Ud over det grundlæggende: FastAPI har understøttelse af WebSockets, Streaming samt GraphQL, udover at have alle de traditionelle hjælpere som CORS, sessioner, cookies og så videre.

Og hvad med præstationen? Nå, FastAPI er bygget på det fantastiske Starlette-bibliotek, hvilket resulterer i ydeevne, der matcher Node, og i nogle tilfælde endda Go! Alt i alt har jeg virkelig på fornemmelsen, at FastAPI kommer til at køre videre som den bedste asynkroniseringsramme for Python.

Konklusion

Der sker meget i Python async-landskabet i disse dage. Nye rammer dukker op, gamle bliver omskrevet, og biblioteker bliver udviklet til at matche asynkron adfærd. Mens Python har indbygget understøttelse af en event-loop, og det er muligt at gøre dele af din applikation asynkron, kan du vælge at gå all-in og bygge videre på et af rammerne her. Bare sørg for at have det langsigtede for øje: Flere af Python async-rammerne derude er i tidlige stadier og udvikles hurtigt, hvilket vil skade din udviklingsproces og øge forretningsomkostningerne. Forsigtighed er nøglen!

Men alt sagt og gjort; Python er produktionsklar til at levere let ydeevne, når det kommer til web-frameworks. Hvis du så længe har tænkt på at migrere til Node, behøver du nu ikke! 🙂

Lyder fedt? Mester Python i dag!