Geekflare est soutenu par notre public. Nous pouvons gagner des commissions d'affiliation en achetant des liens sur ce site.
Partager sur:

Top 9 des cadres Web asynchrones pour Python

frameworks web python
Scanner de sécurité des applications Web Invicti – la seule solution qui offre une vérification automatique des vulnérabilités avec Proof-Based Scanning™.

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 await.

Il s'agissait d'une 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, les vannes de la programmation asynchrone ont été ouvertes : les bibliothèques, nouvelles et anciennes, ont commencé à utiliser la fonction de coroutines, les frameworks asynchrones ont explosé en popularité et de nouveaux sont encore en cours d'écriture aujourd'hui.

Des performances équivalentes 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 CPU, il n'y a aucune raison pour que vous ne puissiez pas effectuer 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.

Tornado

Étonnamment, Tornade n'est pas du tout un nouveau cadre. Sa sortie initiale remonte à 2009 et depuis lors, son objectif a été de fournir une programmation asynchrone solide comme le roc avec une simultanéité élevée.

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.

Quart

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.

FastAPI

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.

BlackSheep

Mouton noir peut être utilisé pour créer des applications côté serveur ou full-stack avec un modèle MVC.

Certaines des fonctionnalités offertes par BlackSheep sont

  • Une API riche en code.
  • Injection de dépendance intégrée.
  • Génération intégrée de la documentation OpenAPI.
  • Liaison automatique des gestionnaires de requêtes.

Configuration du projet

Créons une application de base côté serveur avec BlackSheep. Exécutez rapidement les commandes ci-dessous une par une pour configurer le projet.

python -m venv basic-app
cd basic-app
source bin/activate
pip install blacksheep uvicorn

Nous en avons terminé avec la mise en place du projet. Créons un fichier appelé server.py et placez le code suivant.

from blacksheep import Application

app = Application()

@app.router.get("/")
def home():
    return "Hello, World!"

Nous avons créé notre application Hello World la plus célèbre. Il n'y a qu'un seul itinéraire avec HTTP GET méthode pour l'instant, et c'est /. La fonction home est appelé gestionnaire de requêtes dans BlackSheep.

Nous avons utilisé un router décorateur de l'application. Il existe une autre façon de créer des routes, c'est-à-dire route. Nous utiliserons le router dans ce tutoriel. Vous pouvez en savoir plus sur route dans le docs.

Exécutons l'application avec la commande suivante.

uvicorn server:app --port 8000 --reload

Allez à http://localhost:8000/ dans le navigateur. Vous verrez hello world dans le navigateur. Parlons un peu de la commande que nous avons utilisée pour exécuter l'application.

  • Nous avons utilisé uvicorn package pour exécuter notre application.
  • Les server est le nom du fichier que nous avons donné. Si vous utilisez un nom de fichier différent, modifiez-le également dans la commande de démarrage.
  • L'option --port est de donner le port sur lequel notre application doit s'exécuter.
  • Enfin, la --reload option est de recharger l'application dans le navigateur chaque fois que nous apportons des modifications à la server fichier.

Réponse JSON

Dans le monde réel, nous avons besoin des réponses API en JSON dans la plupart des cas. Nous pouvons renvoyer une réponse JSON à partir de la méthode en enveloppant l'objet JSON avec json du blacksheep forfait. Voyons comment nous pouvons le faire.

from blacksheep import Application, json

app = Application()

@app.router.get("/")
def home():
    return json({"message": "Hello, World!"})

Nous avons importé json du blacksheep et enveloppé l'objet JSON avec. Vérifiez-le dans le navigateur pour la réponse JSON.

Paramètres d'itinéraire

Nous devons parfois accepter les paramètres de route pour les requêtes. Nous pouvons le faire dans BlackSheep en les définissant dans la méthode HTTP. Voyons ça.

@app.router.get("/{name}")
def home(name):
    return json({"greetings": f"Hello, {name}!"})

Nous acceptons un paramètre de route appelé name. Aller à la http://localhost:8000/Geekflare. La méthode renverra un message d'accueil avec le nom donné dans la route.

Le décorateur du routeur passera le paramètre avec le même nom au home fonction telle qu'elle est donnée au décorateur. Ici, ce sera name. Si vous le modifiez dans le décorateur, modifiez-le dans le home fonctionne aussi bien.

Nous pouvons accepter autant de paramètres de route que possible de la même manière. Voyons un exemple rapide.

@app.router.get("/{name}/{info}")
def home(name, info):
    return json({"greetings": f"Hello, {name}! Info {info}"})

Nous avons accepté un autre paramètre de route appelé info. Allez sur http://localhost:8000/Geekflare/Chandan pour le vérifier.

Paramètres de requête

Nous n'avons rien à faire pour accepter les paramètres de la requête. BlackSheep enverra automatiquement les paramètres de requête à la fonction sous la forme d'une liste. Voyons l'exemple.

@app.router.get("/")
def home(name):
    print(name)
    return json({"greetings": f"Hello, {name[0]}!"})

Cliquez sur http://localhost:8000/?name=Geekflare pour vérifier la réponse. Si vous avez plusieurs paramètres de requête portant le même nom, BlackSheep les ajoutera tous à la liste.

Cliquez sur http://localhost:8000/?name=Geekflare&name=Chandan et vérifiez la sortie dans le terminal. Vous verrez une liste avec Geekflare et Chadan car nous avons passé deux paramètres de requête avec le même nom.

Si vous voulez plusieurs paramètres de requête avec différents, vous pouvez le faire aussi. Ajoutez simplement un autre argument à la fonction avec le nom du paramètre de requête et faites ce que vous voulez avec.

Objet de demande

La seule chose qui reste dans nos bases est de vérifier d'autres méthodes HTTP. Avant d'y entrer, vérifions request objet pour l'API.

Tous les gestionnaires de requêtes dans BalckSheep auront un argument de requête contenant toutes les informations de la requête à venir. Il comprend les en-têtes de requête, les paramètres de chemin, les paramètres de requête, les données, etc.,

Voyons un exemple pour voir l'objet de requête.

@app.router.post("/")
def home(request):
    print(request)
    return "Hello, World!"

Vous pouvez voir la sortie suivante dans le terminal.

<Request POST />

Nous pouvons accéder à différentes choses à partir de la requête. Vous pouvez vérifier les docs pour cela. Ici, nous nous concentrons sur le corps de la requête. Voyons comment accéder au corps de la requête à partir de l'objet requête.

@app.router.post("/")
async def home(request):
    data = await request.json()
    print(data)
    return "Hello, World!"

Il existe une méthode appelée json dans la requête, qui renverra les données provenant de la requête. Transmettez des données dans la demande d'API et appelez-la. Vous verrez les données s'imprimer dans le terminal que vous avez transmises à l'API.

Méthodes HTTP

Nous avons vu les méthodes GET et POST dans les exemples ci-dessus. De même, vous pouvez également utiliser les méthodes PUT, DELETE, etc. Essayer vous-même ne sera pas un problème car ils sont simples.

AIOHTTP

aihttp est un autre cadre qui vient avec les fonctionnalités clés suivantes.

  • Il prend en charge les WebSockets côté serveur et côté client.
  • Il prend en charge le développement d'applications serveur et client.
  • Son serveur Web dispose d'un middleware, de signaux et d'un routage enfichable.

Configuration du projet

Créons une application de base côté serveur avec aiohttp. Exécutez rapidement les commandes suivantes pour configurer le projet.

python -m venv basic-app
cd basic-app
source bin/activate
pip install aiohttp aiodns

Créez un fichier appelé server.py et placez-y le code suivant.

from aiohttp import web

async def home(request):
    return web.Response(text="Hello, World!")

app = web.Application()
app.add_routes([web.get('/', home)])

web.run_app(app)

Les web.Application instance est notre application principale. Nous avons ajouté la méthode HTTP GET avec la route / qui renvoie notre monde de salut préféré. La fonction web.run_app est utilisée pour exécuter l'application, qui prend la web.Application exemple comme argument.

La fonction home est appelé un gestionnaire de requêtes dans aiohttp. Et il a un seul et unique argument appelé request, qui contient toutes les informations de la requête entrante.

Exécutez l'application avec la commande suivante. C'est la même chose que d'exécuter des programmes python normaux.

python3 server.py

Cliquez sur http://localhost:8080/ dans le navigateur. Vous verrez hello world dans le navigateur.

Réponse JSON

Nous pouvons renvoyer la réponse au format JSON en utilisant web.json_response fonction. Transmettez les données JSON à cette fonction tout en renvoyant la réponse. Voyons l'exemple.

async def home(request):
    return web.json_response({"message": "Hello, World!"})

Si vous allez à http://localhost:8080/ vous verrez l'objet JSON dans le navigateur.

Paramètres d'itinéraire

Nous pouvons définir les paramètres de route lors de l'ajout des routes. Et ils sont accessibles depuis le request argument du gestionnaire de requêtes. Voyons un exemple.

from aiohttp import web

async def home(request):
    return web.json_response({"message": f"Hello, {request.match_info['name']}!"})

app = web.Application()
app.add_routes([web.get('/{name}', home)])

web.run_app(app)

Tous les paramètres de l'itinéraire sont accessibles depuis le request.match_info comme le montre l'exemple ci-dessus. Aller à http://localhost:8080/Geekflare pour le vérifier.

Nous pouvons également avoir des regex pour faire correspondre les routes. Disons que nous devons accepter seulement /{any_number}. Nous pouvons le faire en remplaçant le '/{name}' avec r'/{number:\d+}'. Nous avons ajouté regex au paramètre path, qui n'acceptera que si la regex est passée.

Voyons voir un exemple

from aiohttp import web

async def home(request):
    return web.json_response({"message": f"Hello, {request.match_info['number']}!"})

app = web.Application()
app.add_routes([web.get(r'/{number:\d+}', home)])

web.run_app(app)

Allez sur http://localhost:8080/Geekflare, vous aurez une erreur 404 comme Geekflare ne correspond pas au modèle regex que nous avons donné. Maintenant, allez à http://localhost:8080/1234567890 vous verrez la réponse dans le navigateur.

Paramètres de requête

Il n'est pas nécessaire d'ajouter quoi que ce soit pour accepter les paramètres de requête. Nous pouvons accepter les paramètres de requête de la request.query objet. Voyons un exemple.

from aiohttp import web

async def home(request):
    return web.json_response({"message": f"Hello, {request.query.get('name')}"})

app = web.Application()
app.add_routes([web.get('/', home)])

web.run_app(app)

Cliquez sur http://localhost:8080/?name=Geekflare et vérifier le résultat. Tu verras Geekflare dans la réponse à laquelle nous accédons à partir du request.query.

Nous pouvons également transmettre plusieurs paramètres de requête accessibles avec leurs noms de clé.

Méthodes HTTP

Nous avons vu comment créer une méthode HTTP GET dans les exemples ci-dessus. Nous devons savoir comment accéder aux données de la demande avant d'aller de l'avant. Voyons-en un exemple.

from aiohttp import web

async def home(request):
    data = await request.json()
    print(data)
    return web.json_response({"message": f"Hello, World!"})

app = web.Application()
app.add_routes([web.post('/', home)])

web.run_app(app)

Dans l'exemple ci-dessus, nous avons changé la méthode API de GET à POST. Nous avons accédé aux données de la demande en utilisant request.json méthode.

Faire une demande de publication à http://localhost:8080/, vous verrez les données de la demande s'imprimer dans le terminal.

De même, vous pouvez également utiliser les méthodes PUT, DELETE, etc. Essayez-les vous-même et amusez-vous.

Vous pouvez continuer à explorer plus sur le cadre dans leur docs.

Falcon

Faucon est un framework ASGI pour créer des API REST et des microservices. Il possède les principales caractéristiques suivantes.

  • Il prend en charge les WebSockets.
  • Prend en charge le middleware et les crochets pour le traitement des demandes.
  • Gestion des exceptions simple et directe.

Configuration du projet

Montons un projet pour apprendre les bases du framework falcon. Configurez le projet avec les commandes suivantes.

python -m venv basic-app
cd basic-app
source bin/activate
pip install falcon uvicorn

Créez un fichier appelé server.py et placez le code suivant.

from falcon import asgi
import falcon


class Home:
    async def on_get(self, request, response):
        response.status = falcon.HTTP_200  # This is the default status
        response.content_type = falcon.MEDIA_TEXT  # Default is JSON, so override
        response.text = 'Hello, World!'

app = asgi.App()
app.add_route('/', Home())

Nous avons créé une classe avec on_get méthode qui est la méthode HTTP GET. La méthode a deux arguments. L'un est request et un autre si response. Vous auriez dû deviner ce qu'ils sont par leurs noms eux-mêmes.

Les request L'argument contient toutes les informations de la requête entrante auxquelles il est possible d'accéder pour traiter la requête. Et le response L'argument est utilisé pour envoyer la réponse en définissant différentes choses.

Contrairement à BlackSheep et AIOHTTP, nous n'avons pas à renvoyer de réponse. Nous pouvons utiliser la réponse et définir les détails que nous devons envoyer en réponse. Dans l'exemple ci-dessus, nous avons défini le statut sur 200, le type de contenu sur texte et le texte sur hello world.

Exécutez l'application avec la commande suivante

uvicorn server:app --reload

Cliquez sur http://localhost:8000/, vous verrez le hello world comme réponse.

Réponse JSON

Nous pouvons renvoyer la réponse au format JSON en convertissant les données en JSON à l'aide de json.dumps méthode. Voyons un exemple

from falcon import asgi
import falcon
import json

class Home:
    async def on_get(self, request, response):
        response.text = json.dumps({"greetings": "Hello, World!"})

app = asgi.App()
app.add_route('/', Home())

Cliquez sur http://localhost:8000/, vous verrez la réponse au format JSON.

Paramètres d'itinéraire

Les paramètres de requête sont transmis aux méthodes HTTP en tant qu'arguments. Vous pouvez voir l'exemple ci-dessous pour une meilleure compréhension.

from falcon import asgi
import falcon
import json

class Home:
    async def on_get(self, request, response, name):
        response.text = json.dumps({"greetings": f"Hello, {name}!"})

app = asgi.App()
app.add_route('/{name}/', Home())

Les name le paramètre de chemin sera passé à on_get méthode comme argument. Aller à http://localhost:8000/Geekflare/ et vérifier la réponse. Nous pouvons avoir autant de paramètres de route que nous voulons.

Paramètres de requête

Nous pouvons accéder aux paramètres de la requête en utilisant request.get_param(param_name) méthode. Consultez l'exemple ci-dessous.

from falcon import asgi
import falcon
import json

class Home:
    async def on_get(self, request, response):
        response.text = json.dumps({"greetings": f"Hello, {request.get_param('name')}!"})

app = asgi.App()
app.add_route('/', Home())

Cliquez sur http://localhost:8000/?name=Geekflare pour vérifier la réponse. Nous pouvons avoir autant de paramètres de requête que nous le souhaitons.

Méthodes HTTP

Nous avons vu la méthode GET dans l'exemple ci-dessus. La seule chose que nous devons savoir pour les autres méthodes est de savoir comment accéder aux données de la demande. Nous pouvons accéder aux données de la demande en utilisant request.stream.read méthode. Voyons un exemple.

from falcon import asgi
import falcon
import json

class Home:
    async def on_get(self, request, response):
        response.text = json.dumps({"greetings": "Hello, World!"})

    async def on_post(self, request, response):
        data = await request.stream.read()
        print(json.loads(data))
        response.text = "Hello, World!"

app = asgi.App()
app.add_route('/', Home())

Nous avons ajouté une méthode POST dans laquelle nous avons accédé aux données de la requête et les avons imprimées sur le terminal après les avoir converties en JSON. Faites une requête POST avec des données pour vérifier la sortie.

Essayez d'ajouter vous-même d'autres méthodes HTTP telles que DELETE, PUT, etc. Nous n'avons converti que les bases du framework falcon. Mais, il y a beaucoup dedans. Allez lire le docs pour en savoir plus en profondeur.

Starlette

Starlette est un framework ASGI léger en Python. Il possède presque toutes les fonctionnalités de base pour créer des applications côté serveur.

Configurez le projet avec les commandes suivantes.

python -m venv basic-app
cd basic-app
source bin/activate
pip install starlette uvicorn

Créer des API avec Starlette est similaire à ce que nous avons vu dans les derniers frameworks. La syntaxe et la manière de créer des API sont différentes. Tous les concepts restent les mêmes. Donc, nous allons inclure toutes les choses dans un seul programme.

Créez un fichier appelé server.py et placez le code suivant.

from starlette.applications import Starlette
from starlette.responses import PlainTextResponse, JSONResponse
from starlette.routing import Route


def homepage(request):
    return PlainTextResponse('Hello, World!')

def json_response(request):
    return JSONResponse({'message': 'Hello, World!'})

def path_params(request):
    name = request.path_params['name']
    return JSONResponse({'greetings': f'Hello, {name}!'})

def query_params(request):
    name = request.query_params['name']
    return JSONResponse({'greetings': f'Hello, {name}!'})

async def post_method(request):
    data = await request.json()
    print(data)
    return JSONResponse({'message': f'Hello, World!'})

def startup():
    print('Starlette started')

routes = [
    Route('/', homepage),
    Route('/json', json_response),
    Route('/path-params/{name}', path_params),
    Route('/query-params', query_params),
    Route('/post', post_method, methods=['POST']),
]

app = Starlette(debug=True, routes=routes, on_startup=[startup])

Exécutez l'application avec la commande suivante.

uvicorn server:app --reload

Testez tout ce que nous avons vu dans les frameworks précédents. Vous pouvez en savoir plus sur le framework Starlette dans son docs.

Conclusion

Il se passe beaucoup de choses dans le paysage asynchrone Python ces jours-ci. Nouveau cadres apparaissent, les anciennes sont réécrites 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 tout-en-un et de vous appuyer sur l'un des frameworks ici.

Assurez-vous simplement de garder à l'esprit le long terme : 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 de l'entreprise.

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!

Merci à nos commanditaires
Plus de bonnes lectures sur le développement
Alimentez votre entreprise
Certains des outils et services pour aider votre entreprise à se développer.
  • Invicti utilise Proof-Based Scanning™ pour vérifier automatiquement les vulnérabilités identifiées et générer des résultats exploitables en quelques heures seulement.
    Essayez Invicti
  • Web scraping, proxy résidentiel, proxy manager, web unlocker, moteur de recherche et tout ce dont vous avez besoin pour collecter des données Web.
    Essayez Brightdata
  • Semrush est une solution de marketing numérique tout-en-un avec plus de 50 outils de référencement, de médias sociaux et de marketing de contenu.
    Essayez Semrush
  • Intruder est un scanner de vulnérabilités en ligne qui détecte les failles de cybersécurité de votre infrastructure, afin d'éviter des violations de données coûteuses.
    Essayez Intruder