Asynkron programmering har nå en sentral posisjon i Python. For de som jobber med webutvikling, finnes det et mangfold av fantastiske rammeverk å velge blant!
I dagens situasjon er ikke asynkron programmering bare et moteord i Python-miljøet. Med introduksjonen av asyncio-biblioteket i versjon 3.5, anerkjente Python betydningen av Node.js for webutvikling. Dette resulterte i at to nye nøkkelord, «async» og «await», ble inkludert i språket. Dette var en betydelig hendelse, da Python-språket vanligvis er svært forsiktig med å utvide kjerne syntaksen, med mindre det er et sterkt behov. Dette viser hvor fundamentalt viktig Python-utviklerne anså de asynkrone mulighetene.
Dette åpnet dørene for asynkron programmering: Både nye og gamle biblioteker begynte å ta i bruk coroutines-funksjonen. Asynkrone rammeverk opplevde en enorm popularitetsvekst, og det utvikles stadig nye. Ytelse på lik linje med eller bedre enn Node.js er ikke uvanlig, og med mindre dine lastmønstre innebærer mange CPU-krevende oppgaver, er det ingen grunn til at du ikke kan håndtere flere tusen forespørsler per sekund.
Men nok motivasjon!
La oss nå se nærmere på det nåværende Python-landskapet og undersøke noen av de fremste asynkrone rammeverkene.
Tornado
Overraskende nok er Tornado ikke et nytt rammeverk. Det ble først lansert i 2009, og har siden den gang fokusert på å tilby stabil asynkron programmering med høy samtidighet.
Tornado er i bunn og grunn ikke bare et webrammeverk. Det er en samling asynkrone moduler som også brukes for å utvikle webrammemodulen. Mer konkret består disse modulene av:
- Coroutines og andre primitiver (tornado.gen, tornado.locks, tornado.queues, osv.)
- Nettverksmoduler (tornado.ioloop, tornado.iostream, osv.)
- Asynkrone servere og klienter (tornado.httpserver, tornado.httpclient, osv.)
Disse modulene kombineres for å danne de endelige rammeverksmodulene: tornado.web, tornado.routing, tornado.template, osv.
import tornado.ioloop
import tornado.web
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.write("Hallo, verden")
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 stor og engasjert følgerskare i Python-fellesskapet og benyttes av erfarne utviklere til å bygge svært kapable systemer. Det er et rammeverk som lenge har hatt løsninger for utfordringene knyttet til samtidighet, men som kanskje ikke har oppnådd like stor utbredelse da det ikke støtter WSGI-standarden og krever en betydelig innsats (husk at de fleste Python-biblioteker fremdeles er synkrone).
Sanic
Sanic er et moderne rammeverk i ordets rette forstand: Det støtter ikke Python-versjoner under 3.6, det har innebygd støtte for den enkle og universelle async/await-syntaksen, og som et resultat trenger du ikke å lese store mengder dokumentasjon og ha mange spesielle forhold i bakhodet før du kan skrive din første HTTP-behandler.
Den resulterende syntaksen er derfor ganske behagelig (i alle fall etter min mening); den ligner koden du ville skrevet med et annet mikrorammeverk (som Flask eller CherryPy), med noen få asynkrone elementer tilføyd:
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 uten tvil det mest populære og verdsatte asynkrone rammeverket i Python-verdenen. Det har nesten alle de funksjonene du trenger for dine prosjekter – ruting, mellomvare, informasjonskapsler, versjonskontroll, blueprints, klassebaserte visninger, statiske filer, strømming, sockets, osv. Og det den ikke tilbyr direkte – som maler, databasestøtte, fil I/O, køer – kan legges til, ettersom det nå finnes et tilstrekkelig antall asynkrone biblioteker for disse formålene.
Vibora
Vibora er nært beslektet med Sanic, men fokuserer på å være den raskeste Python-nettserveren på markedet. Faktisk møtes du av en ytelsessammenligning på forsiden av nettstedet:
Som du ser hevder Vibora å være flere ganger raskere enn de klassiske rammeverkene, og mer enn dobbelt så rask som sin nærmeste konkurrent Sanic. Ytelsesresultater bør selvfølgelig tolkes med forsiktighet. 🙂
Selv om Vibora har lik syntaks og funksjonalitet som Sanic (eller kanskje litt bedre, siden det samler populære biblioteker og funksjoner som maler er tilgjengelige direkte), vil jeg vurdere Sanic som mer modent da det har eksistert lenger og har et større fellesskap.
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 opptatt av ytelse, kan Vibora være noe for deg. Likevel er Vibora for tiden inne i en fullstendig omstrukturering for å bli enda raskere, og lenken til ytelsesversjonen indikerer at den er under «intens utvikling». Dette vil være skuffende for de som tidligere valgte Vibora og snart må håndtere endringer som bryter med eksisterende kode. Men slik er det i Python asynkrone verden; ingen forventer stabilitet på dette tidspunktet.
Quart
Hvis du liker å utvikle i Flask, men savner asynkron støtte, vil du finne Quart svært tilfredsstillende.
Quart er kompatibel med ASGI-standarden, som er en etterfølger av den kjente WSGI-standarden og tilbyr asynkron støtte. Det spesielle med Quart er at det ikke bare ligner på Flask, men faktisk er kompatibelt med Flask API! Forfatteren av rammeverket ønsket å bevare Flask-opplevelsen og bare legge til async, WebSockets og HTTP 2-støtte. Dermed kan du lære Quart ved hjelp av Flask-dokumentasjonen; husk bare at funksjoner i Quart er asynkrone.
from quart import Quart
app = Quart(__name__)
@app.route('/')
async def hello():
return 'hello'
app.run()
Føles (nesten) akkurat som Flask, ikke sant?!
Siden Quart er en videreutvikling av Flask, er alle funksjonene i Flask tilgjengelige: ruting, mellomvare, økter, maler, blueprints, osv. Du kan til og med bruke Flask-utvidelser direkte i Quart. En ulempe er at kun Python 3.7+ støttes, men hvis du ikke kjører den nyeste versjonen av Python, er kanskje asynkron programmering uansett ikke det rette valget for deg. 🙂
Dokumentasjonen kan virke mangelfull dersom du ikke har tidligere erfaring med Flask. Likevel vil jeg anbefale Quart da det sannsynligvis er det eneste asynkrone rammeverket som snart nærmer seg 1.0-utgivelsen.
FastAPI
Det siste (men mest imponerende) rammeverket på denne listen er FastAPI. Det er ikke bare et API-rammeverk; faktisk virker FastAPI som det mest funksjonsrike og godt dokumenterte rammeverket jeg har kommet over i min utforskning av asynkrone Python-rammeverk.
Det er verdt å merke seg at rammeverkets skaper har studert flere andre rammeverk grundig, fra moderne rammeverk som Django til like moderne rammeverk som Sanic, samt teknologier som NestJS (et Node.js-basert nettrammeverk i Typescript). Utviklingsfilosofien og omfattende sammenligninger kan leses her.
Syntaksen er ganske tiltalende; noen vil kanskje til og med påstå at den er langt mer behagelig enn de andre rammeverkene vi har sett på:
from 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}
Her er en liste over viktige funksjoner som gjør at FastAPI skiller seg ut fra andre rammeverk:
Automatisk generering av API-dokumentasjon: Så snart endepunktene dine er skrevet, kan du interagere med API-et ved å bruke et standardkompatibelt brukergrensesnitt. SwaggerUI, ReDoc og andre verktøy støttes.
Rammeverket lager også automatisk datamodelldokumentasjon med JSON Schema.
Moderne utvikling: Ja, ordet «moderne» brukes ofte, men jeg opplevde at FastAPI virkelig lever opp til forventningene. Dependency Injection og type hinting er sentrale elementer, som ikke bare fremmer gode kodingsprinsipper, men også forebygger feil og forvirring over tid.
Omfattende dokumentasjon: Jeg vet ikke med deg, men jeg setter stor pris på god dokumentasjon. Og på dette feltet vinner FastAPI uten tvil. Den har sider på sider med dokumenter som forklarer nesten alle små detaljer og «vær forsiktig»-øyeblikk for utviklere på alle nivåer. Det er tydelig at det ligger mye hjerte og sjel i dokumentasjonen, og den eneste sammenligningen jeg kan gjøre er med Django-dokumentasjonen (ja, FastAPI-dokumentasjonen er så bra!).
Utover det grunnleggende: FastAPI har støtte for WebSockets, strømming og GraphQL, i tillegg til alle de tradisjonelle hjelpefunksjonene som CORS, økter, informasjonskapsler, osv.
Og hva med ytelsen? FastAPI er bygget på det utmerkede Starlette-biblioteket, noe som resulterer i ytelse som kan sammenlignes med Node, og i enkelte tilfeller til og med Go! Alt i alt har jeg en sterk følelse av at FastAPI vil etablere seg som det fremste asynkrone rammeverket for Python.
Konklusjon
Det skjer mye i Python asynkrone verden om dagen. Nye rammeverk dukker opp, gamle skrives om, og biblioteker utvikles for å fungere asynkront. Mens Python har innebygd støtte for en event loop og det er mulig å gjøre deler av applikasjonen din asynkron, kan du velge å satse fullt ut og bygge på et av rammeverkene som er presentert her. Husk å ha langsiktige perspektiver i tankene: Flere av de asynkrone Python-rammeverkene er i tidlig fase og utvikles raskt. Dette kan påvirke utviklingsprosessen negativt og øke forretningskostnadene. Vær forsiktig!
Men alt i alt er Python klar for produksjon og kan levere høy ytelse når det gjelder webrammeverk. Hvis du har vurdert å migrere til Node, trenger du ikke det nå! 🙂
Høres dette spennende ut? Bli en ekspert i Python i dag!