Créer une application avec FastAPI pour Python

FastAPI est un framework Web rapide et léger permettant de créer des interfaces de programmation d'applications modernes à l'aide de Python 3.6 et versions ultérieures. Dans ce didacticiel, nous allons parcourir les bases de la création d'une application avec FastAPI, et vous comprendrez pourquoi elle a été désignée comme l'un des meilleurs frameworks open source de 2021.

Une fois que vous êtes prêt à développer vos propres applications FastAPI, vous n'aurez pas à chercher bien loin pour trouver un endroit pour les héberger. Les services d'hébergement d'applications et d'hébergement de bases de données de Kinsta fournissent une plate-forme en tant que service qui est forte sur Python.

Apprenons d'abord les bases.

Avantages de FastAPI

Vous trouverez ci-dessous certains des avantages que le framework FastAPI apporte à un projet.

• Vitesse : Comme son nom l'indique, FastAPI est un framework très rapide. Sa vitesse est comparable à celle de Go et Node.js, qui sont généralement considérés comme parmi les options les plus rapides pour créer des API.
• Facile à apprendre et à coder : FastAPI a déjà compris presque tout ce dont vous aurez besoin pour créer une API prête pour la production. En tant que développeur utilisant FastAPI, vous n'avez pas besoin de tout coder à partir de zéro. Avec seulement quelques lignes de code, vous pouvez avoir une API RESTful prête à être déployée.
• Documentation complète : FastAPI utilise les normes de documentation OpenAPI, de sorte que la documentation peut être générée dynamiquement. Cette documentation fournit des informations détaillées sur les points de terminaison, les réponses, les paramètres et les codes de retour de FastAPI.
• API avec moins de bogues : FastAPI prend en charge la validation des données personnalisées, ce qui permet aux développeurs de créer des API avec moins de bogues. Les développeurs de FastAPI se vantent que le framework entraîne moins de bogues induits par l'homme - jusqu'à 40% de moins.
• Conseils de type : le module types a été introduit dans Python 3.5. Cela permet de déclarer le type d'une variable. Lorsque le type d'une variable est déclaré, les IDE sont en mesure de fournir un meilleur support et de prédire les erreurs avec plus de précision.

Comment démarrer avec FastAPI

Pour suivre ce didacticiel et démarrer avec FastAPI, vous devez d'abord effectuer quelques opérations.

Assurez-vous que vous disposez d'un éditeur de texte/IDE d'un programmeur, tel que Visual Studio Code. Les autres options incluent Sublime Text et Espresso.

Il est courant que vos applications Python et leurs instances s'exécutent dans des environnements virtuels. Les environnements virtuels permettent à différents ensembles de packages et configurations de s'exécuter simultanément et évitent les conflits dus à des versions de packages incompatibles.

Pour créer un environnement virtuel, ouvrez votre terminal et exécutez cette commande :

 $ python3 -m venv env

Vous devrez également activer l'environnement virtuel. La commande pour ce faire varie en fonction du système d'exploitation et du shell que vous utilisez. Voici quelques exemples d'activation CLI pour un certain nombre d'environnements :

 # On Unix or MacOS (bash shell): /path/to/venv/bin/activate # On Unix or MacOS (csh shell): /path/to/venv/bin/activate.csh # On Unix or MacOS (fish shell): /path/to/venv/bin/activate.fish # On Windows (command prompt): \path\to\venv\Scripts\activate.bat # On Windows (PowerShell): \path\to\venv\Scripts\Activate.ps1

(Certains IDE compatibles Python peuvent également être configurés pour activer l'environnement virtuel actuel.)

Maintenant, installez FastAPI :

 $ pip3 install fastapi

FastAPI est un framework pour créer des API, mais pour tester vos API, vous aurez besoin d'un serveur Web local. Uvicorn est un serveur Web ASGI (Asynchronous Server Gateway Interface) ultra-rapide pour Python, idéal pour le développement. Pour installer Uvicorn, exécutez cette commande :

 $ pip3 install "uvicorn[standard]"

Une fois l'installation réussie, créez un fichier nommé main.py dans le répertoire de travail de votre projet. Ce fichier sera le point d'entrée de votre candidature.

Un exemple rapide FastAPI

Vous testerez votre installation FastAPI en configurant rapidement un exemple de point de terminaison. Dans votre fichier main.py , collez le code suivant, puis enregistrez le fichier :

 # main.py from fastapi import FastAPI app = FastAPI() @app.get("/") async def root(): return {"greeting":"Hello world"}

L'extrait ci-dessus crée un point de terminaison FastAPI de base. Vous trouverez ci-dessous un résumé de ce que fait chaque ligne :

• from fastapi import FastAPI : La fonctionnalité de votre API est fournie par la classe FastAPI Python.
• app = FastAPI() : Cela crée une instance FastAPI.
• @app.get("/") : Il s'agit d'un décorateur python qui spécifie à FastAPI que la fonction en dessous est en charge de la gestion des requêtes.
• @app.get("/") : il s'agit d'un décorateur qui spécifie la route. Cela crée une méthode GET sur la route du site. Le résultat est ensuite renvoyé par la fonction enveloppée.
• Les autres opérations possibles utilisées pour communiquer incluent @app.post() , @app.put() , @app.delete() , @app.options() , @app.head() , @app.patch() , et @app.trace() .

Dans le répertoire des fichiers, exécutez la commande suivante dans votre terminal pour démarrer le serveur d'API :

 $ uvicorn main:app --reload

Dans cette commande, main est le nom de votre module. L'objet app est une instance de votre application et est importé dans le serveur ASGI. L'indicateur --reload indique au serveur de se recharger automatiquement lorsque vous apportez des modifications.

Vous devriez voir quelque chose comme ça dans votre terminal :

 $ uvicorn main:app --reload INFO: Will watch for changes in these directories: ['D:\\WEB DEV\\Eunit\\Tests\\fast-api'] INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) INFO: Started reloader process [26888] using WatchFiles INFO: Started server process [14956] INFO: Waiting for application startup. INFO: Application startup complete.

Dans votre navigateur, accédez à http://localhost:8000 pour confirmer que votre API fonctionne. Vous devriez voir "Hello": "World" comme un objet JSON sur la page. Cela illustre à quel point il est facile de créer une API avec FastAPI. Tout ce que vous aviez à faire était de définir une route et de renvoyer votre dictionnaire Python, comme indiqué à la ligne six de l'extrait ci-dessus.

Utilisation des conseils de type

Si vous utilisez Python, vous avez l'habitude d'annoter des variables avec des types de données de base tels que int , str , float et bool . Cependant, à partir de la version 3.9 de Python, des structures de données avancées ont été introduites. Cela vous permet de travailler avec des structures de données telles que des dictionaries , des tuples et lists . Avec les indications de type de FastAPI, vous pouvez structurer le schéma de vos données à l'aide de modèles pydantic, puis utiliser les modèles pydantic pour taper l'indication et bénéficier de la validation des données fournie.

Dans l'exemple ci-dessous, l'utilisation d'indications de type en Python est démontrée avec un simple calculateur de prix de repas, calculate_meal_fee :

 def calculate_meal_fee(beef_price: int, meal_price: int) -> int: total_price: int = beef_price + meal_price return total_price print("Calculated meal fee", calculate_meal_fee(75, 19))

Notez que les indications de type ne modifient pas l'exécution de votre code.

Documentation de l'API interactive FastAPI

FastAPI utilise l'interface utilisateur Swagger pour fournir une documentation API interactive automatique. Pour y accéder, accédez à http://localhost:8000/docs et vous verrez un écran avec tous vos points de terminaison, méthodes et schémas.

Cette documentation API automatique basée sur un navigateur est fournie par FastAPI, et vous n'avez rien d'autre à faire pour en tirer parti.

Une autre documentation d'API basée sur un navigateur, également fournie par FastAPI, est Redoc. Pour accéder à Redoc, accédez à http://localhost:8000/redoc , où une liste de vos points de terminaison, des méthodes et de leurs réponses respectives vous sera présentée.

Configuration des itinéraires dans FastAPI

Le décorateur @app vous permet de spécifier la méthode de la route, telle que @app.get ou @app.post , et prend en charge GET , POST , PUT et DELETE , ainsi que les options moins courantes, HEAD , PATCH et TRACE .

Construire votre application avec FastAPI

Dans ce didacticiel, vous serez guidé dans la création d'une application CRUD avec FastAPI. L'application pourra :

• Créer un utilisateur
• Lire l'enregistrement de la base de données d'un utilisateur
• Mettre à jour un utilisateur existant
• Supprimer un utilisateur particulier

Pour exécuter ces opérations CRUD, vous allez créer des méthodes qui exposent les points de terminaison de l'API. Le résultat sera une base de données en mémoire pouvant stocker une liste d'utilisateurs.

Vous utiliserez la bibliothèque pydantic pour effectuer la validation des données et la gestion des paramètres à l'aide d'annotations de type Python. Pour les besoins de ce didacticiel, vous déclarerez la forme de vos données sous forme de classes avec des attributs.

Ce didacticiel utilisera la base de données en mémoire. Il s'agit de vous permettre de démarrer rapidement avec FastAPI pour créer vos API. Cependant, pour la production, vous pouvez utiliser n'importe quelle base de données de votre choix, telle que PostgreSQL, MySQL, SQLite ou même Oracle.

Construire l'application

Vous commencerez par créer votre modèle utilisateur. Le modèle utilisateur aura les attributs suivants :

• id : Un identifiant unique universel (UUID)
• first_name : Le prénom de l'utilisateur
• last_name : Le nom de famille de l'utilisateur
• gender : Le sexe de l'utilisateur
• roles , qui est une liste contenant les rôles d' admin et user

Commencez par créer un nouveau fichier nommé models.py dans votre répertoire de travail, puis collez le code suivant dans models.py pour créer votre modèle :

 # models.py from typing import List, Optional from uuid import UUID, uuid4 from pydantic import BaseModel from enum import Enum from pydantic import BaseModel class Gender(str, Enum): male = "male" female = "female" class Role(str, Enum): admin = "admin" user = "user" class User(BaseModel): id: Optional[UUID] = uuid4() first_name: str last_name: str gender: Gender roles: List[Role]

Dans le code ci-dessus :

• Votre classe User étend BaseModel , qui est ensuite importée de pydantic .
• Vous avez défini les attributs de l'utilisateur, comme indiqué ci-dessus.

La prochaine étape consiste à créer votre base de données. Remplacez le contenu de votre fichier main.py par le code suivant :

 # main.py from typing import List from uuid import uuid4 from fastapi import FastAPI from models import Gender, Role, User app = FastAPI() db: List[User] = [ User( id=uuid4(), first_name="John", last_name="Doe", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Jane", last_name="Doe", gender=Gender.female, roles=[Role.user], ), User( id=uuid4(), first_name="James", last_name="Gabriel", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Eunit", last_name="Eunit", gender=Gender.male, roles=[Role.admin, Role.user], ), ]

Dans main.py :

• Vous avez initialisé db avec un type de List et passé dans le modèle User
• Vous avez créé une base de données en mémoire avec quatre utilisateurs, chacun avec les attributs requis tels que first_name , last_name , gender et roles . L'utilisateur Eunit se voit attribuer les rôles d' admin et user , tandis que les trois autres utilisateurs se voient attribuer uniquement le rôle d' user .

Lire les enregistrements de la base de données

Vous avez configuré avec succès votre base de données en mémoire et l'avez peuplée d'utilisateurs. L'étape suivante consiste donc à configurer un point de terminaison qui renverra une liste de tous les utilisateurs. C'est là qu'intervient FastAPI.

Dans votre fichier main.py , collez le code suivant juste en dessous de votre point de terminaison Hello World :

 # main.py @app.get("/api/v1/users") async def get_users(): return db

Ce code définit le point de terminaison /api/v1/users et crée une fonction asynchrone, get_users , qui renvoie tout le contenu de la base de données, db .

Enregistrez votre fichier et vous pourrez tester votre point de terminaison utilisateur. Exécutez la commande suivante dans votre terminal pour démarrer le serveur d'API :

 $ uvicorn main:app --reload

Dans votre navigateur, accédez à http://localhost:8000/api/v1/users . Cela devrait renvoyer une liste de tous vos utilisateurs, comme indiqué ci-dessous :

À ce stade, votre fichier main.py ressemblera à ceci :

 # main.py from typing import List from uuid import uuid4 from fastapi import FastAPI from models import Gender, Role, User app = FastAPI() db: List[User] = [ User( id=uuid4(), first_name="John", last_name="Doe", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Jane", last_name="Doe", gender=Gender.female, roles=[Role.user], ), User( id=uuid4(), first_name="James", last_name="Gabriel", gender=Gender.male, roles=[Role.user], ), User( id=uuid4(), first_name="Eunit", last_name="Eunit", gender=Gender.male, roles=[Role.admin, Role.user], ), ] @app.get("/") async def root(): return {"Hello": "World",} @app.get("/api/v1/users") async def get_users(): return db

Créer des enregistrements de base de données

L'étape suivante consiste à créer un point de terminaison pour créer un nouvel utilisateur dans votre base de données. Collez l'extrait de code suivant dans votre fichier main.py :

 # main.py @app.post("/api/v1/users") async def create_user(user: User): db.append(user) return {"id": user.id}

Dans cet extrait, vous avez défini le point de terminaison pour soumettre un nouvel utilisateur et utilisé le décorateur @app.post pour créer une méthode POST .

Vous avez également créé la fonction create_user , qui accepte l' user du modèle User , et ajouté (ajouté) l' user nouvellement créé à la base de données, db . Enfin, le point de terminaison renvoie un objet JSON de l' id de l'utilisateur nouvellement créé.

Vous devrez utiliser la documentation automatique de l'API fournie par FastAPI pour tester votre point de terminaison, comme vu ci-dessus. En effet, vous ne pouvez pas effectuer de demande de publication à l'aide du navigateur Web. Accédez à http://localhost:8000/docs pour tester à l'aide de la documentation fournie par SwaggerUI.

Supprimer les enregistrements de la base de données

Puisque vous construisez une application CRUD, votre application devra avoir la possibilité de supprimer une ressource spécifiée. Pour ce didacticiel, vous allez créer un point de terminaison pour supprimer un utilisateur.

Collez le code suivant dans votre fichier main.py :

 # main.py from uuid import UUID from fastapi HTTPException @app.delete("/api/v1/users/{id}") async def delete_user(id: UUID): for user in db: if user.id == id: db.remove(user) return raise HTTPException( status_code=404, detail=f"Delete user failed, id {id} not found." )

Voici une ventilation ligne par ligne du fonctionnement de ce code :

• @app.delete("/api/v1/users/{id}") : vous avez créé le point de terminaison de suppression à l'aide du @app.delete() . Le chemin est toujours /api/v1/users/{id} , mais il récupère ensuite l' id , qui est une variable de chemin correspondant à l'id de l'utilisateur.
• async def delete_user(id: UUID): : crée la fonction delete_user , qui récupère l' id à partir de l'URL.
• for user in db: : cela indique à l'application de parcourir les utilisateurs de la base de données et de vérifier si l' id transmis correspond à un utilisateur de la base de données.
• db.remove(user) : Si l' id correspond à un utilisateur, l'utilisateur sera supprimé ; sinon, une HTTPException avec un code d'état de 404 sera levée.

Mettre à jour les enregistrements de la base de données

Vous allez créer un point de terminaison pour mettre à jour les détails d'un utilisateur. Les détails pouvant être mis à jour incluent les paramètres suivants : first_name , last_name et roles .

Dans votre fichier models.py , collez le code suivant sous votre modèle User , c'est-à-dire après la classe User(BaseModel): :

 # models.py class UpdateUser(BaseModel): first_name: Optional[str] last_name: Optional[str] roles: Optional[List[Role]]

Dans cet extrait, la classe UpdateUser étend BaseModel . Vous définissez ensuite les paramètres utilisateur pouvant être mis à jour, tels que first_name , last_name et roles , comme étant facultatifs.

Vous allez maintenant créer un point de terminaison pour mettre à jour les détails d'un utilisateur particulier. Dans votre fichier main.py , collez le code suivant après le décorateur @app.delete :

 # main.py @app.put("/api/v1/users/{id}") async def update_user(user_update: UpdateUser, id: UUID): for user in db: if user.id == id: if user_update.first_name is not None: user.first_name = user_update.first_name if user_update.last_name is not None: user.last_name = user_update.last_name if user_update.roles is not None: user.roles = user_update.roles return user.id raise HTTPException(status_code=404, detail=f"Could not find user with id: {id}")

Dans le code ci-dessus, vous avez effectué les opérations suivantes :

• Créé @app.put("/api/v1/users/{id}") , le point de terminaison de mise à jour. Il a un paramètre variable id qui correspond à l'id de l'utilisateur.
• Création d'une méthode appelée update_user , qui prend en compte la classe et l' id UpdateUser .
• Utilisation d'une boucle for pour vérifier si l'utilisateur associé à l' id passé est dans la base de données.
• Vérifié si l'un des paramètres de l'utilisateur is not None (non nul). Si un paramètre, tel que first_name , last_name ou roles n'est pas nul, il est mis à jour.
• Si l'opération réussit, l'ID utilisateur est renvoyé.
• Si l'utilisateur n'a pas été localisé, une exception HTTPException avec un code d'état de 404 et un message Could not find user with id: {id} est déclenchée.

Pour tester ce point de terminaison, assurez-vous que votre serveur Uvicorn est en cours d'exécution. S'il n'est pas en cours d'exécution, saisissez cette commande :

 uvicorn main:app --reload

Ci-dessous, une capture d'écran du test.

Découvrez comment FastAPI pourrait supprimer jusqu'à 40 % des bogues induits par l'homme. Commencez ici :  Cliquez pour tweeter

Sommaire

Dans ce didacticiel, vous avez découvert le framework FastAPI pour Python et constaté par vous-même à quelle vitesse vous pouvez mettre en place et exécuter une application alimentée par FastAPI. Vous avez appris à créer des points de terminaison d'API CRUD à l'aide du framework - création, lecture, mise à jour et suppression d'enregistrements de base de données.

Maintenant, si vous souhaitez faire passer le développement de votre application Web au niveau supérieur, assurez-vous de consulter la plate-forme Kinsta pour l'hébergement d'applications et l'hébergement de bases de données. Comme FastAPI, c'est puissamment simple.