[PYTHON] Mémo du didacticiel FastAPI, partie 1

introduction

FastAPI Souce: https://github.com/tiangolo/fastapi FastAPI Document: https://fastapi.tiangolo.com

Intro & First Step Notes pour le didacticiel FastAPI. En gros, je me réfère au tutoriel officiel de Fast API, mais j'oublie certaines parties ou change l'ordre de mon propre apprentissage. Veuillez vous référer à la documentation officielle pour les informations correctes et détaillées.

Étant donné que je suis un débutant en Web et Python et que je compte sur Google et DeepL pour la traduction, je vous serais reconnaissant si vous pouviez signaler les erreurs.

Environnement de développement

Ubuntu 20.04 LTS Python 3.8.2 pipenv 2018.11.26

Cible

1. [Installer FastAPI](#Install FastAPI)
2. [Démarrer le serveur](# Démarrer le serveur)
3. [Vérifier l'interface utilisateur Swagger](# Interface utilisateur Swagger-Check)
4. [Vérifier le code](# Vérifier le code)

Qu'est-ce que FastAPI

FastAPI est un framework Web rapide, léger et moderne pour la création d'API basées sur des indices de type Python. Il est conforme à OpenAPI (Swagger), qui est un standard ouvert d'API, et au schéma JSON. Veuillez consulter le Document officiel pour plus de détails.

procédure

Installation rapide de l'API

Installez FastAPI en utilisant pip. Vous pouvez installer toutes les dépendances et fonctionnalités utilisées par l'API Fast avec la commande suivante, donc installons avec cette commande pour le moment dans l'environnement de développement. Vous pouvez également installer ʻuvicorn`, qui est utilisé comme serveur, dans un lot.

$ pip install fastapi[all]

████████████████████████████████████████ 100%

Vérifions-le avec le shell interactif de python.

$ python
Python 3.8.2 (default, Apr 21 2020, 18:13:10) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 
>>> from fastapi import FastAPI
>>> 

Si aucune erreur ne s'affiche, l'installation est réussie. De plus, comme j'utilise pipenv dans mon environnement, je l'ai installé avec pipenv install fastapi [all], mais il n'y a pas de problème pour l'instant.

Je vais l'omettre ici, mais il est également possible d'installer fastapi et ʻuvicorn` séparément.

Démarrez le serveur

Maintenant que vous avez installé FastAPI, démarrons le serveur tout de suite.

Tout d'abord, écrivez un simple code Fast API dans le fichier main.py. (Le code est essentiellement tiré du document officiel. Veuillez vérifier Référence.)

main.py

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
async def root():
    return {"message": "Hello World"}

Après avoir enregistré le code, démarrez le serveur avec la commande suivante.

$ uvicorn main:app --reload

Si l'affichage suivant s'affiche, le serveur est en cours d'exécution.

INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO: Started reloader process [28720]
INFO: Started server process [28722]
INFO: Waiting for application startup.
INFO: Application startup complete.

La sortie a la ligne ʻINFO: Uvicorn fonctionnant sur http://127.0.0.1:8000 (Appuyez sur CTRL + C pour quitter) `. Il semble vous indiquer l'URL (http://127.0.0.1:8000) où l'application s'exécute sur votre ordinateur local et comment arrêter le serveur (touche Ctrl + C).

Affichons immédiatement http://127.0.0.1:8000 dans le navigateur. Vous devriez voir la valeur de retour de la fonction root dans main.py (return {"message": "Hello World"}).

À propos de ʻuvicorn main: app --reload`

• Reportez-vous au fichier main.py (= module Python) pour main
• Le nom du fichier peut être défini librement. Changeons-le en control.py etc. Dans ce cas, vous devez également modifier la commande. --ʻApp fait référence à l'objet créé par ʻapp = FastAPI dans le fichier main.py ――Ceci peut être défini librement ainsi que le nom du fichier. ---- reload est une option pour redémarrer le serveur à chaque fois que le code change
• Cette option est recommandée pour une utilisation uniquement dans un environnement de développement.

Vérifiez l'interface utilisateur de Swagger

FastAPI est compatible OpenAPI et génère automatiquement une documentation API interactive avec Swagger UI. Visitez http://127.0.0.1:8000/docs pour vérifier.

Vous pouvez également consulter la documentation par ReDoc en visitant http://127.0.0.1:8000/redoc.

Vérifiez le code

Vérifions le contenu de main.py. Ce code est le code de base de l'API Fast.

Importation API rapide

Tout d'abord, importez la classe FastAPI. Ce FastAPI fournit toutes les fonctionnalités de l'API que vous créez.

from fastapi import FastAPI

Créer une instance

Ensuite, créez une variable qui sera une instance de l'API Fast. Cette variable est l'entité de l'API Fast.

from fastapi import FastAPI

app = FastAPI()

La variable d'instance ʻapp créée ici correspond à l'option main: app de la commande ʻuvicorn. Si le nom du fichier est control.py et la variable d'instance est my_instance = FastAPI (), la commande ʻuvicorn` sera la suivante.

$ uvicorn control:my_instance --reload

INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)

Création d'une opération de chemin

** Chemin ** ici fait référence à la partie de l'URL qui commence par / après le nom de domaine et le nom du port. Dans le cas de l'URL https: // exemple.com / items / foo, la partie / items / foo correspond au chemin dans l'API rapide.

Vous pouvez également considérer Path comme ayant la même signification que les ** points de terminaison ** et ** route ** généraux. Dans FastAPI, le rôle de ** Path ** est "séparation des" préoccupations "(intérêt) et" ressource "(ressource) dans la construction de l'API". Cela signifie-t-il diviser le programme en unités d'intérêt (objectif, ce que vous voulez faire) et en ressources (ressources, ce que vous utilisez)? S'il vous plaît laissez-moi savoir si vous avez des détails.

De plus, Path Operation ** Operation ** est synonyme de méthode HTTP. Les principales méthodes utilisées sont:

--POST: Création de données

• OBTENIR: Lire les données --PUT: mise à jour des données --DELETE: Supprimer les données

HTTP peut communiquer avec chaque chemin du serveur Web en utilisant ces méthodes. Lors de la construction de l'API, nous utilisons ces méthodes HTTP pour effectuer certaines actions.

La méthode HTTP est appelée ** opération ** dans OpenAPI, et le terme ** opération ** est utilisé dans FastAPI en conséquence.

Définissons ** le décorateur d'opération de chemin ** en utilisant des variables d'instance.

from fastapi import FastAPI

app = FastAPI()


@app.get("/")

La fonction décoratrice @ app.get (" / ") permet à l'API Fast de gérer les requêtes suivantes en utilisant la fonction immédiatement ci-dessous.

• ** chemin ** est / et -Utiliser la méthode get pour ** opération **

Voir d'autres articles pour les fonctions de décorateur. Ici, il est utilisé pour indiquer à l'API Fast que la fonction directement sous la fonction décoratrice correspond à ** path/**. De plus, une telle fonction de décorateur est appelée ** décorateur d'opération de chemin **.

Vous pouvez également utiliser des opérations autres que «get» comme indiqué ci-dessous.

• @app.post()
• @app.put()
• @app.delete()

Définition de la fonction d'opération de chemin

À la fin de la vérification du code, définissez la fonction de manipulation de chemin et définissez la valeur de retour.

Le décorateur d'opération de chemin @ app.get (" / ") nous a permis de définir une requête HTTP comme point de départ du traitement. Ensuite, définissez la fonction pour effectuer le traitement juste en dessous du décorateur.

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
async def root():

La fonction de manipulation de chemin utilisée ici (ʻasync def root (): ) n'est pas différente d'une fonction Python normale. L'API rapide appelle cette fonction chaque fois que le client envoie une requête à l'URL / avec get`operation et que le serveur la reçoit. (Je voulais également que cette fonction soit appelée lorsque j'accédais à http://127.0.0.1:8000.)

Vous pouvez également définir une fonction régulière au lieu de ʻasync def`.

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def root():
    return {"message": "Hello World"}

Pour ʻasync` (traitement asynchrone), reportez-vous au document officiel de ici.

Après cela, définissez la valeur de retour avec return, et la confirmation du premier code sera terminée.

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
async def root():
    return {"message": "Hello World"}

Concernant la valeur de retour, vous pouvez définir la valeur de retour avec des types tels que dict et list pour plusieurs valeurs et str et ʻint` pour des valeurs uniques. Alternativement, il est possible de renvoyer un modèle «Pydantic». En plus de ce qui précède, il existe de nombreux objets et modèles (y compris ORM) qui sont automatiquement convertis en JSON. Vérifie s'il te plaît.

Enfin sur OpenAPI

Cette fois, parmi les tutoriels officiels de l'API Fast, Intro et Premiers pas Je l'ai ramassé. Enfin, jetons un coup d'œil à l'API ouverte et au schéma.

Qu'est-ce que l'API ouverte?

Open API est un format d'écriture d'API REST, et Swagger est un ensemble d'outils open source à utiliser lors de l'écriture d'API Open. Il a été brièvement résumé dans l'article suivant.

• OpenAPI (Swagger) Super Introduction
• What Is OpenAPI?

Dans FastAPI, les définitions d'API sont conformes à OpenAPI et toutes les API génèrent un «schéma».

Qu'est-ce qu'un schéma?

Un «schéma» est une définition ou une description. Il fait référence à un concept abstrait et non à un code implémenté.

Schéma d'API

Lors de l'examen du «schéma» dans une API, OpenAPI est une spécification qui spécifie comment définir le schéma de l'API créée.

Cette définition de schéma inclut le chemin d'accès à l'API et les paramètres que l'API peut obtenir.

Schéma de données

Le mot «schéma» peut également désigner une forme de données, telle que le contenu JSON.

Dans ce cas, cela signifie les attributs de JSON et les types de données dont ils disposent.

Relation entre le schéma OpenAPI et JSON

OpenAPI définit le «schéma API» de l'API créée, qui utilise le «schéma JSON» qui est le standard du schéma de données JSON pour définir les données envoyées et reçues par l'API (ou d'autres «schémas»). Il contient.

FastAPI utilise le schéma OpenAPI pour exécuter deux types de systèmes de documents interactifs (Swagger UI, ReDoc).

référence

Introduction au didacticiel officiel FastAPI Premiers pas du didacticiel officiel FastAPI