• Assurez la sécurité des applications de la bonne manière! Détectez, protégez, surveillez, accélérez et plus encore…
  • La programmation asynchrone est maintenant un citoyen de première classe en Python. Si vous êtes un développeur Web, il y a des cadres vous pouvez choisir!

    Au moment de l'écriture, asynchrone n'est plus qu'un mot à la mode dans la communauté Python. Avec la sortie de son asynchrone bibliothèque en version 3.5, Python a reconnu l'impact de Node.js sur le développement Web et introduit deux nouveaux mots-clés dans le langage - async et de await. Ce fut un très gros problème car le langage Python est extrêmement prudent d'étendre la syntaxe de base à moins qu'il n'y ait un besoin pressant, ce qui indique seulement à quel point les développeurs Python ont considéré les capacités asynchrones comme fondamentalement importantes.

    En conséquence, des vannes de programmation asynchrone ont été ouvertes: les bibliothèques nouvelles et anciennes ont commencé à utiliser la fonctionnalité coroutines, les frameworks asynchrones ont explosé en popularité et de nouveaux sont toujours en cours d'écriture aujourd'hui. Des performances égales ou supérieures à celles de Node.js ne sont pas inconnues, et à moins que vos modèles de chargement n'impliquent de nombreuses tâches gourmandes en ressources processeur, il n'y a aucune raison pour que vous ne puissiez pas faire quelques milliers de requêtes par seconde.

    Mais assez de motivation!

    Examinons le paysage Python actuel et découvrons quelques-uns des meilleurs frameworks asynchrones.

    Tornade

    Étonnamment, Tornade n'est pas du tout un nouveau cadre. Sa sortie initiale remonte à 2009 (il y a exactement dix ans, au moment de la rédaction) et depuis lors, son objectif est de fournir une programmation asynchrone à toute épreuve avec une forte concurrence.

    Tornado n'est pas fondamentalement un framework Web. C'est une collection de modules asynchrones, qui sont également utilisés pour créer le module de structure Web. Plus précisément, ces modules sont:

    • Coroutines et autres primitives (tornado.gen, tornado.locks, tornado.queues, Etc)
    • Modules de mise en réseau (tornado.ioloop, tornado.iostream, Etc)
    • Serveurs et clients asynchrones (tornado.httpserver, tornado.httpclient, Etc)

    Ceux-ci ont été combinés pour produire les modules finaux du cadre: 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()

    Tornado a une clientèle forte et engagée dans la communauté Python et est utilisé par des architectes expérimentés pour créer des systèmes hautement performants. C'est un framework qui a depuis longtemps la réponse aux problèmes de concurrence mais qui n'est peut-être pas devenu courant car il ne prend pas en charge la norme WSGI et était trop favorable (rappelez-vous que la plupart des bibliothèques Python sont toujours synchrones ).

    Sanic

    Sanic est un framework «moderne» dans le vrai sens du terme: il ne prend pas en charge la version Python inférieure à 3.6, prend en charge la syntaxe simple et universelle async / await hors de la boîte, et par conséquent, ne vous fait pas lire des charges de la documentation et gardez à l'esprit les cas extrêmes avant de pouvoir écrire votre premier gestionnaire HTTP.

    En conséquence, la syntaxe obtenue est assez agréable (à mon avis, du moins); il ressemble au code que vous écririez avec n'importe quel autre microframework (Flask, CherryPy, par exemple) avec juste quelques async saupoudré dans:

    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 est sans doute le framework async le plus populaire et le plus apprécié du monde Python. Il possède presque toutes les fonctionnalités que vous souhaitez pour vos projets - routage, middleware, cookies, gestion des versions, plans, vues basées sur les classes, fichiers statiques, streaming, sockets, etc. - et ce qu'il n'offre pas prêt à l'emploi - création de modèles, prise en charge de bases de données, E / S de fichiers, files d'attente - peuvent être ajoutés car il y a juste assez de bibliothèques asynchrones pour celles-ci à partir d'aujourd'hui.

    Vibora

    Vibora est un proche cousin de Sanic, sauf qu'il est résolu à devenir le serveur Web Python le plus rapide du marché. En fait, la toute première visite de son site Web vous accueille avec une comparaison de cadres:

    Comme vous pouvez le voir, Vibora prétend être plusieurs fois plus rapide que les frameworks classiques et être plus de deux fois plus rapide que Sanic, son concurrent le plus proche. Bien sûr, les repères doivent être pris avec un grain de sel. 🙂

    Bien que dans la syntaxe et les fonctionnalités, Vibora soit comparable à Sanic (ou peut-être même légèrement meilleur car il regroupe des bibliothèques populaires et des éléments comme la création de modèles sont disponibles immédiatement), je considérerais que Sanic est plus mature car il existe depuis plus longtemps et a une plus grande communauté.

    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)

    Si vous êtes un accro de la performance, cependant, Vibora pourrait faire flotter votre bateau. Cela dit, au moment d'écrire ces lignes, Vibora subit une réécriture complète pour devenir encore plus rapide, et le lien à sa version de performance dit qu'il est en «développement intensif». Ce sera une déception pour ceux qui ont choisi Vibora plus tôt et devront bientôt faire face à des changements révolutionnaires, mais bon, c'est le début du monde asynchrone Python, et personne ne s'attend à ce que les choses soient stables.

    Trimestre,fr

    Si vous aimez développer dans Flask mais que vous regrettez le manque de support asynchrone, vous apprécierez Trimestre,fr beaucoup.

    Quart est conforme à la ASGIA standard, qui succède au célèbre standard WSGI et offre une prise en charge asynchrone. Ce qui est intéressant à propos de Quart, c'est qu'il n'est pas seulement similaire à Flask, mais qu'il est en fait conforme à l'API Flask! L'auteur de ce framework voulait préserver la sensation Flask et y ajouter simplement le support async, WebSockets et HTTP 2. Par conséquent, vous pouvez apprendre Quart directement à partir de la documentation Flask, en gardant simplement à l'esprit que les fonctions de Quart sont asynchrones.

    from quart import Quart
    
    app = Quart(__name__)
    
    @app.route('/')
    async def hello():
        return 'hello'
    
    app.run()

    Se sent (presque) exactement comme Flask, n'est-ce pas?!

    Étant donné que Quart est une évolution de Flask, toutes les fonctionnalités de Flask sont disponibles: routage, middleware, sessions, création de modèles, plans, etc. En fait, vous pouvez même utiliser les extensions Flask directement dans Quart. Un problème est que Python 3.7+ est uniquement pris en charge, mais si vous n'exécutez pas la dernière version de Python, peut-être que l'async n'est pas le bon chemin. 🙂

    La documentation est vraiment nécessaire si vous n'avez pas d'expérience antérieure avec Flask, mais je peux recommander Quart car c'est probablement le seul framework async qui s'approche bientôt de sa version 1.0.

    API rapide

    Le dernier cadre (mais le plus impressionnant) de cette liste est API rapide. Non, ce n'est pas un framework uniquement API; en fait, FastAPI semble être le framework le plus riche en fonctionnalités et en documentation que j'ai rencontré lors de la recherche de frameworks Python asynchrones.

     

    Il est intéressant de noter que l'auteur du framework a étudié en profondeur plusieurs autres frameworks, des frameworks contemporains comme Django aux plus modernes comme Sanic, ainsi qu'en examinant les technologies dans NestJS (un framework Web Node.js, Typescript). Leur philosophie de développement et leurs comparaisons approfondies peuvent être lues ici.

    La syntaxe est assez agréable; on peut même dire que c'est beaucoup plus agréable que les autres frameworks que nous avons rencontrés:

    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}

    Et maintenant, la liste des fonctionnalités qui font de FastAPI sur les autres frameworks:

    Génération automatique de documents API: Dès que vos points de terminaison ont été écrits, vous pouvez jouer avec l'API en utilisant une interface utilisateur conforme aux normes. SwaggerUI, ReDoc et autres sont pris en charge.

    Le framework effectue également une documentation automatique du modèle de données avec JSON Schema.

    Développement moderne: Oui, le mot «moderne» est souvent répandu, mais j'ai trouvé que FastAPI s'exprime réellement. L'injection de dépendance et l'indication de type sont des citoyens de première classe, appliquant non seulement de bons principes de codage, mais évitant les bogues et la confusion à long terme.

    Documentation complète: Je ne sais pas pour vous, mais je suis un amateur de bonne documentation. Et dans ce domaine, FastAPI gagne haut la main. Il contient des pages sur des pages de documents expliquant presque chaque petite subtilité et «attention!» moments pour les développeurs de tous niveaux. Je sens clairement «cœur et âme» dans les documents ici, et la seule comparaison que je peux trouver est les documents Django (oui, les documents FastAPI sont si bons!).

    Au-delà des bases: FastAPI prend en charge WebSockets, Streaming, ainsi que GraphQL, en plus d'avoir tous les assistants traditionnels comme CORS, les sessions, les cookies, etc.

    Et qu'en est-il de la performance? Eh bien, FastAPI est construit sur l'incroyable bibliothèque Starlette, ce qui donne des performances qui correspondent à Node, et dans certains cas, même Go! Dans l'ensemble, j'ai vraiment le sentiment que FastAPI va devenir le meilleur framework async pour Python.

    Conclusion

    Beaucoup de choses se passent dans le paysage asynchrone Python ces jours-ci. De nouveaux frameworks apparaissent, les anciens sont en cours de réécriture et les bibliothèques évoluent pour correspondre au comportement asynchrone. Bien que Python ait un support intégré pour une boucle d'événements et qu'il soit possible de rendre certaines parties de votre application asynchrones, vous pouvez choisir d'aller all-in et de construire sur l'un des frameworks ici. Assurez-vous simplement de garder le long terme à l'esprit: plusieurs des frameworks asynchrones Python en sont à leurs débuts et évoluent rapidement, ce qui va nuire à votre processus de développement et augmenter les coûts commerciaux. La prudence est la clé!

    Mais tout est dit et fait; Python est prêt pour la production pour offrir des performances légères en matière de frameworks Web. Si depuis si longtemps vous envisagez de migrer vers Node, vous n'en avez plus besoin! 🙂

    Cela paraît bien? Maîtrisez Python aujourd'hui!