Dans ce tutoriel, nous allons créer une API asynchrone en Python en utilisant Flask et Asyncio. Après cela, nous testerons également l’API. Mais avant cela, comprenons ce qu’est l’API asynchrone ? Vous avez peut-être beaucoup entendu parler de la programmation asynchrone et synchrone, n’est-ce pas ?

La programmation asynchrone est une méthode par laquelle nous réalisons une programmation parallèle. En cela, nous définissons plusieurs threads où ils s’exécutent indépendamment du programme ou de la fonction principale. Par exemple, il y a un code qui doit être exécuté. Ainsi, le compilateur commencera par le haut du fichier et ira jusqu’en bas de l’écran. Mais, la différence est que lors de l’exécution, il rencontrera certaines fonctions asynchrones. Ces fonctions créeront leurs threads et seront exécutées simultanément avec la fonction principale. Ces fonctions asynchrones s’exécuteront indépendamment de la fonction principale.

En revanche, en programmation synchrone, le programme commencera l’exécution de haut en bas. Une différence est qu’il ne créera pas plusieurs threads. Ainsi, tout sera exécuté ligne par ligne contrairement à l’asynchrone où deux ou plusieurs fonctions peuvent être exécutées en même temps.

Fondamentalement, en programmation asynchrone, la fonction peut être exécutée dans n’importe quel ordre. En programmation synchrone, les fonctions seront exécutées de haut en bas.

Comment fonctionne l’API asynchrone ?

L’API asynchrone en Python suit le même principe de programmation asynchrone. Ces API ne renvoient pas les données immédiatement. Ils fournissent un rappel au client lorsque les résultats sont prêts. En attendant, le client peut continuer à exécuter d’autres fonctions pendant que l’API prépare les résultats.

Ces API sont très utiles dans les applications où les éléments sont indépendants les uns des autres. Par exemple, vous pouvez utiliser ces API dans la page d’accueil d’un site Web de commerce électronique. Où vous avez des tuiles de différents produits. Étant donné que les produits ne dépendent pas d’autres éléments, l’API peut être utilisée pour charger des produits et d’autres éléments.

Il y a aussi un inconvénient, ces API ne conviennent pas là où vous avez besoin d’une réponse instantanée de l’API car la latence est le problème ici.

Create-Asynchronous-API-in-Python

Maintenant, nous avons couvert beaucoup de choses sur l’API asynchrone. Essayons de créer une API asynchrone en Python !

Conditions préalables

  • Connaissance de base de Python
  • Compréhension de la programmation asynchrone
  • Virtualenv installé

Modules que nous utiliserons

enfilage

Ce package est utilisé pour introduire plusieurs threads dans le programme. Lorsqu’un programme est exécuté, il est considéré comme un processus et à l’intérieur d’un processus, il y a un thread. Lorsqu’un programme est exécuté de manière synchrone, il crée un processus sous lequel il y a un thread. Mais quand il y a un programme asynchrone, il y a un processus mais il y a plus d’un thread.

Par exemple, s’il y a un programme dans lequel il y a deux fonctions asynchrones. Cela créera donc un processus et deux threads. Le module de threading nous aide à créer plusieurs threads dans un programme python.

asynchrone

Ce module vous permet d’écrire du code concurrent en utilisant la syntaxe async/wait. Il est utilisé pour créer des fonctions asynchrones en Python. Il est également livré avec des bibliothèques pour établir des connexions à la base de données, ajouter des files d’attente, etc. Asyncio vous permet également d’exécuter des routines simultanément, de contrôler le sous-processus, de distribuer des tâches, de créer et de gérer des boucles d’événements.

ballon

Ainsi, toutes les bibliothèques ci-dessus ont aidé notre code à rendre notre code multithread, introduit async/wait, etc. Nous créons des API, n’est-ce pas ? Nous avons également besoin de points de terminaison API, n’est-ce pas ? C’est là que le flacon nous aidera.

Commençons maintenant par la configuration du projet.

Étape -1 : Configuration de l’environnement

Créez maintenant un dossier „flasksync“ et ouvrez-le. Ça sonne bien, non ? Flacon + Async. 

mkdir flasksync
cd flasksync

Une fois que vous êtes dans le dossier, initialisons l’environnement virtuel : 

virtualenv .

Une fois initialisé, installons toutes les dépendances : 

pip3 install Flask
pip3 install asyncio

Nous en avons maintenant terminé avec la configuration de l’environnement. Passons à la partie la plus intéressante, à savoir le codage.

Étape 2 : Création de points de terminaison d’API

Créez maintenant un fichier „api.py“ et ouvrez-le dans un éditeur de code.

Commençons par les instructions d’importation. Collez donc le code ci-dessous pour importer tous les modules requis : 

import threading
import asyncio
from flask import Flask, jsonify

Une fois cela fait, essayons d’obtenir le nom du premier fil : 

print(f"In flask global level: {threading.current_thread().name}")
app = Flask(__name__)

La ligne de code ci-dessus essaiera d’obtenir le nom du thread actuel.

Après cela, nous devrons créer un point de terminaison API où nous pourrons tester la nature asynchrone de l’API : 

@app.route("/test", methods=["GET"])
def index():
    print(f"Inside flask function: {threading.current_thread().name}")
    asyncio.set_event_loop(asyncio.new_event_loop())
    loop = asyncio.get_event_loop()
    result = loop.run_until_complete(hello())
    return jsonify({"result": result})

Explication des codes :

Nous avons défini un point de terminaison d’API /test où nous allons définir une boucle d’événement. Une fois la boucle définie, nous essaierons d’obtenir cet événement en appelant la fonction get_event_loop(). La boucle continuera à s’exécuter jusqu’à ce qu’une réponse soit renvoyée par hello(). Une fois le résultat prêt, nous le renverrons dans la réponse.

Un point à retenir ici est que hello() est une fonction asynchrone ici.

Nous allons maintenant définir la fonction asynchrone hello() : 

async def hello():
    await asyncio.sleep(5)
    return 1


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=4567, debug=False)

La fonction ne fera rien, attendra simplement de manière asynchrone pendant 5 secondes, puis renverra 1.

À la fin, votre code devrait ressembler à ceci : 

import threading
import asyncio
from flask import Flask, jsonify


print(f"In flask global level: {threading.current_thread().name}")
app = Flask(__name__)

@app.route("/test", methods=["GET"])
def index():
    print(f"Inside flask function: {threading.current_thread().name}")
    asyncio.set_event_loop(asyncio.new_event_loop())
    loop = asyncio.get_event_loop()
    result = loop.run_until_complete(hello())
    return jsonify({"result": result})


async def hello():
    await asyncio.sleep(5)
    return 1


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=4567, debug=False)

Étape -3 : Tester l’API

Avant d’exécuter le serveur, nous devons exécuter une commande : 

export FLASK_APP=api.py

Une fois cela fait, lançons le serveur en utilisant la commande : 

flask run

Ouvrez maintenant votre outil de test d’API préféré et faites une requête GET à l’URL http://127.0.0.1:5000/test. Vous aurez votre résultat prêt en 5 secondes :

Create-Asynchronous-API-in-Python

Derniers mots

Dans cet article, nous avons couvert le fonctionnement de l’API asynchrone et comment créer une API asynchrone en Python. Ce n’était qu’un point essentiel, vous pouvez créer différents points de terminaison d’API, puis les utiliser avec votre application. Cela vous aidera à améliorer considérablement l’expérience utilisateur car les éléments indépendants n’ont plus besoin d’attendre l’appel d’API précédent pour récupérer la réponse. Vous pouvez également découvrir comment nous avons automatisé nos publications sur Twitter.

Voici quelques tutoriels utiles que vous pouvez lire :