Az 5 legjobb aszinkron webes keretrendszer a Python számára

Az aszinkron programozás ma már első osztályú polgár a Pythonban. Ha Ön webfejlesztő, csodálatos keretrendszerek közül választhat!

Íráskor az aszinkron már nem csak egy divatszó a Python közösségben. A megjelenésével asyncio könyvtár 3.5-ös verziójában a Python elismerte a Node.js webfejlesztésre gyakorolt hatását, és két új kulcsszót vezetett be a nyelvbe: az async és a wait. Ez nagyon nagy dolog volt, mert a Python nyelv rendkívül óvatos az alapvető szintaxis kiterjesztésével, hacsak nincs sürgető szükség, ami csak azt jelzi, hogy a Python fejlesztői mennyire alapvetően fontosnak tartották az aszinkron képességeket.

Ennek eredményeként megnyíltak az aszinkron programozás zsilipjei: új és régi könyvtárak kezdték használni a korutin funkciót, az aszinkron keretrendszerek népszerűsége robbanásszerűen megnőtt, és ma is készülnek újak. A Node.js-éval megegyező vagy annál jobb teljesítmény nem ismeretlen, és ha a betöltési minták nem tartalmaznak sok CPU-igényes feladatot, nincs ok arra, hogy ne tudna másodpercenként néhány ezer kérést végrehajtani.

De elég a motiváció!

Tekintsük át a jelenlegi Python-környezetet, és nézzünk meg néhány legnépszerűbb aszinkron keretrendszert.

Tartalomjegyzék

Tornádó

Meglepően, Tornádó egyáltalán nem új keretrendszer. Első kiadása 2009-ben volt (pontosan tíz éve, az írás pillanatában), és azóta a hangsúly a sziklaszilárd aszinkron programozáson van, magas párhuzamossággal.

A Tornado alapvetően nem egy webes keretrendszer. Ez aszinkron modulok gyűjteménye, amelyeket a webes keretrendszer modul felépítéséhez is használnak. Pontosabban ezek a modulok:

Korutinok és más primitívek (tornado.gen, tornado.locks, tornado.queues stb.)
Hálózati modulok (tornado.ioloop, tornado.iostream stb.)
Aszinkron szerverek és kliensek (tornado.httpserver, tornado.httpclient stb.)

Ezeket kombinálták a végső keretmodulok létrehozásához: tornado.web, tornado.routing, tornado.template stb.

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

A Tornado erős és elkötelezett követője van a Python közösségben, és tapasztalt építészek használják kiváló rendszerek felépítésére. Ez egy olyan keretrendszer, amely már régóta megvan a válasz a párhuzamosság problémáira, de talán nem vált általánossá, mivel nem támogatja a WSGI szabványt, és túlságosan nagy nevezési díj volt (ne feledje, hogy a Python-könyvtárak nagy része még mindig szinkronban működik ).

Valószínűleg rosszul csúsztatja az ujját az iPhone X-en. Így kell csinálni

Sanic

Sanic egy „modern” keretrendszer a szó valódi értelmében: nem támogatja a Python 3.6 alatti verzióját, támogatja az egyszerű és univerzális aszinkron/várakozás szintaxist, és ennek eredményeként nem kényszeríti az olvasót az olvasásra. dokumentációt, és tartsa szem előtt az éles eseteket, mielőtt megírná az első HTTP-kezelőt.

Ennek eredményeként a kapott szintaxis meglehetősen kellemes (legalábbis véleményem szerint); hasonlít arra a kódra, amelyet bármilyen más mikrokeretrendszerrel írna (például Flask, CherryPy), és csak néhány aszinkron van benne:

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)

A Sanic vitathatatlanul a legnépszerűbb és legkedveltebb aszinkron keretrendszer a Python világban. Szinte minden olyan funkcióval rendelkezik, amelyet a projektjeihez szeretne – útválasztás, köztes szoftver, cookie-k, verziókezelés, tervrajzok, osztályalapú nézetek, statikus fájlok, adatfolyam, socketek stb. — sablonok, adatbázis-támogatás, fájl I/O, sorok — hozzáadhatók, mivel ezekhez a mai napig éppen elég aszinkron könyvtár áll rendelkezésre.

Vibora

Vibora a Sanic közeli rokona, azzal a különbséggel, hogy az a cél, hogy a leggyorsabb Python webszerver legyen. Valójában a webhely legelső látogatása egy keretösszehasonlítással üdvözli Önt:

Amint látható, a Vibora többszörösen gyorsabb a klasszikus kereteknél, és több mint kétszer olyan gyors, mint a legközelebbi versenytárs, a Sanic. Természetesen a viszonyítási pontokat egy kis sóval kell felfogni. 🙂

Bár szintaxisában és szolgáltatásaiban a Vibora összehasonlítható a Sanic-el (vagy talán még valamivel jobb is, mivel a népszerű könyvtárakat köti össze, és olyan dolgok, mint a sablonok már a dobozból is elérhetők), a Sanic-ot érettebbnek tartanám, mivel már régebb óta létezik, és egy nagyobb közösség.

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)

Ha azonban teljesítményfüggő, Vibora lebegtetheti a hajóját. Ennek ellenére a Vibora írás közben egy teljes újraíráson dolgozik, hogy még gyorsabb legyen, és a link teljesítményű verziója szerint „erős fejlesztés alatt áll”. Ez csalódás lesz azoknak, akik korábban vették fel a Viborát, és hamarosan megtörő változásokkal kell szembenézniük, de hát ez a Python aszinkron világának kezdeti szakasza, és senki sem várja el, hogy a dolgok stabilak legyenek.

A VLC Media Player frissítése

Kvart

Ha szereti a Flaskban való fejlesztést, de sajnálja az aszinkron támogatás hiányát, élvezni fogja Kvart nagyon.

Quart megfelel a ASGI szabvány, amely a híres WSGI szabvány utódja, és aszinkron támogatást kínál. A Quart érdekessége, hogy nem csak a Flask-hoz hasonlít, de valójában kompatibilis a Flask API-val! A keretrendszer szerzője meg akarta őrizni a Flask érzést, és csak az async, a WebSockets és a HTTP 2 támogatást kívánta hozzáadni. Ennek eredményeként megtanulhatja a Quartot közvetlenül a Flask dokumentációjából, csak tartsa szem előtt, hogy a Quart funkciói aszinkronok.

from quart import Quart

app = Quart(__name__)

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

app.run()

Pontosan olyan (majdnem) olyan, mint a Lombik, nem igaz?

Mivel a Quart a Flask továbbfejlesztése, a Flask összes szolgáltatása elérhető: útválasztás, köztes szoftver, szekciók, sablonok, tervrajzok és így tovább. Valójában a Flask bővítményeket közvetlenül a Quart belsejében is használhatja. Az egyik bökkenő az, hogy csak a Python 3.7+ támogatott, de ha nem a Python legújabb verzióját futtatja, akkor lehet, hogy az aszinkron nem a megfelelő út. 🙂

A dokumentáció nagyon fontos, ha nincs korábbi tapasztalata a Flask-val, de tudom ajánlani a Quartot, mivel valószínűleg ez az egyetlen aszinkron keretrendszer, amely hamarosan az 1.0-s kiadásához közeledik.

FastAPI

Az utolsó (de leglenyűgözőbb) keret ezen a listán az FastAPI. Nem, ez nem csak API-keretrendszer; Valójában a FastAPI tűnik a leginkább funkciókban és dokumentációban gazdag keretrendszernek, amellyel az aszinkron Python-keretrendszerek kutatása során találkoztam.

Érdekes megjegyezni, hogy a keretrendszer szerzője több más keretrendszert is behatóan tanulmányozott, a kortársaktól, mint a Django, a modernekig, mint a Sanic, valamint a technológiák között a NestJS-be (Node.js, Typescript webes keretrendszer) is belenézett. Fejlesztési filozófiájuk és kiterjedt összehasonlításaik olvashatók itt.

A szintaxis meglehetősen kellemes; Akár vitatkozni is lehet, hogy sokkal élvezetesebb, mint a többi keretrendszer, amellyel találkoztunk:

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}

És most, a gyilkos funkciók listája, amelyek miatt a FastAPI felülmúlja a többi keretrendszert:

Hogyan kell játszani a Minecraftot Linuxon a GDLauncher segítségével

Automatikus API-dokumentumok generálása: Amint a végpontjai megírásra kerültek, a szabványoknak megfelelő felhasználói felület használatával játszhat az API-val. A SwaggerUI, a ReDoc és mások támogatottak.

A keretrendszer automatikus adatmodell-dokumentációt is végez a JSON-sémával.

Modern fejlesztés: Igen, a „modern” szót gyakran szórják, de úgy találtam, hogy a FastAPI tulajdonképpen beszédet mond. A Dependency Injection és a típus-hinting első osztályú állampolgárok, nemcsak a jó kódolási elveket érvényesítik, hanem hosszú távon megelőzik a hibákat és a zavart.

Kiterjedt dokumentáció: Nem tudom, ti hogy vagytok vele, de én totál balek vagyok a jó dokumentációért. Ezen a területen pedig a FastAPI győzedelmeskedik. Oldalról oldalra olyan dokumentumokat tartalmaz, amelyek szinte minden apró finomságot elmagyaráznak, és „vigyázz!” pillanatok minden szintű fejlesztő számára. Egyértelmű „szívet és lelket” érzékelek az itteni dokumentumokban, és az egyetlen összehasonlítás, amit találok, a Django-dokumentumok (igen, a FastAPI-dokumentumok olyan jók!).

Az alapokon túl: A FastAPI támogatja a WebSockets-et, a Streaming-et és a GraphQL-t, amellett, hogy rendelkezik minden hagyományos segítővel, mint például a CORS, a munkamenetek, a cookie-k és így tovább.

És mi a helyzet az előadással? Nos, a FastAPI a csodálatos Starlette könyvtárra épül, és olyan teljesítményt eredményez, amely megfelel a Node-nak, és bizonyos esetekben még a Go! Összességében az az érzésem, hogy a FastAPI a Python legjobb aszinkron keretrendszereként fog versenyezni.

Következtetés

Manapság sok minden történik a Python aszinkron környezetben. Új keretrendszerek bukkannak fel, a régieket átírják, és a könyvtárakat fejlesztik, hogy megfeleljenek az aszinkron viselkedésnek. Míg a Python beépített támogatással rendelkezik az eseményhurokhoz, és lehetőség van az alkalmazás egyes részei aszinkronizálására, dönthet úgy, hogy all-in megy, és az itt található keretrendszerek egyikére épít. Csak ügyeljen arra, hogy a hosszú távot tartsa szem előtt: a Python async keretrendszerek közül több is korai szakaszban van, és gyorsan fejlődnek, ami árt a fejlesztési folyamatnak, és növeli az üzleti költségeket. Az óvatosság kulcsfontosságú!

De minden mondva és kész; A Python készen áll a termelésre, hogy könnyű teljesítményt nyújtson a webes keretrendszerek terén. Ha olyan régóta gondolkodik a Node-ra való átálláson, most nincs rá szüksége! 🙂

Jól hangzik? Mester Python ma!