IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

FastAPI : un framework pour la création d'API avec Python 3.6+ basées sur des déclarations de type Python standard
Avec des performances qui égaleraient celles de Node.js et Go

Le , par Bill Fassinou

278PARTAGES

3  0 
Un nouveau framework Web Python pour le développement d'API fait son apparition dans la communauté. Créateur de FastAPI, Sebastián Ramírez, développeur Web full-stack et ingénieur en apprentissage automatique, décrit son outil comme étant un framework Web moderne et rapide (haute performance) pour la construction d'API avec Python 3.6+, basé sur des déclarations (hints) de type Python standard. FastAPI intègre de nombreuses fonctionnalités pour la création facile d'API et son auteur lui cite un grand nombre de caractéristiques importantes. Voici ci-dessous un aperçu de ce dont il s'agit.

FastAPI : définitions et caractéristiques essentielles

Alors, pourquoi un nouveau framework Web Python ? « J'évite la création d'un nouveau framework depuis plusieurs années. J'ai d'abord essayé de résoudre toutes les fonctionnalités couvertes par FastAPI en utilisant de nombreux frameworks, plug-ins et outils différents. Mais à un moment donné, il n'y avait pas d'autre option que de créer quelque chose qui fournisse toutes ces fonctionnalités, en prenant les meilleures idées des outils précédents, et en les combinant de la meilleure façon possible, en utilisant des fonctionnalités de langage qui n'étaient même pas disponibles auparavant (des déclarations de type Python 3.6+) », a répondu Ramírez.



Comme Ramirez le définit, FastAPI est un framework moderne qui vous permet de créer des API de manière transparente sans trop d'efforts. Il a la capacité de séparer le code du serveur de la logique-métier, ce qui augmente la maintenabilité du code. Il serait plus rapide que Flask, car il est construit sur ASGI (Asynchronous Server Gateway Interface) au lieu de WSGI (Web Server Gateway Interface). Il dispose d'un système de validation des données qui peut détecter tout type de données invalides au moment de l'exécution et renvoie la raison des mauvaises entrées à l'utilisateur au seul format JSON.

Cela libère les développeurs de la gestion explicite de cette exception. En outre, il génère la documentation en cours d'exécution lorsque vous développez l'API, ce qui est aujourd'hui l'une des choses les plus demandées par les développeurs. La documentation est un excellent moyen pour les autres développeurs de collaborer sur un projet, car elle leur présente tout ce qui peut être fait avec les instructions nécessaires. FastAPI génère également une interface graphique, ce qui constitue un aide pour les développeurs. En tant que développeur, vous vous concentrez uniquement sur la partie de construction de la logique et le reste est géré par FastAPI.

Voici les caractéristiques importantes de FastAPI mis en avant par sa documentation :

  • rapide : FastAPI afficherait de très hautes performances, à la hauteur de Node.js et Go (grâce à Starlette et Pydantic). Il serait en effet l'un des frameworks Web Python les plus rapides du marché ;
  • rapide à coder : FastAPI augmenterait la vitesse de développement des fonctionnalités d'environ 200 % à 300 % ;
  • moins de bogues : FastAPI réduirait d'environ 40 % les erreurs humaines (des développeurs) ;
  • intuitif : FastAPI a un excellent support de l'éditeur. La complétion existe partout et il nécessite moins de temps pour le débogage ;
  • facile : FastAPI est conçu pour être facile à utiliser et à apprendre. Il faut peu de temps pour lire les documents ;
  • court : FastAPI réduirait au minimum la duplication du code et permettrait de multiples fonctionnalités à partir de chaque déclaration de paramètres, ce qui permet de réduire les bogues ;
  • robuste : FastAPI permet d'obtenir un code prêt à la production avec une documentation interactive automatique ;
  • basé sur des normes : FastAPI est basé sur, et entièrement compatible avec les normes ouvertes pour les API OpenAPI (anciennement connu sous le nom de Swagger) et JSON Schema.

Quelques détails sur les fonctionnalités clés de FastAPI

Documentation automatique

FastAPI génère automatiquement une documentation API interactive et des interfaces utilisateur Web d'exploration. Comme le framework est basé sur OpenAPI, il y a plusieurs options, dont deux sont incluses par défaut. L'interface utilisateur Swagger, avec l'exploration interactive, permet d'appeler et de tester votre API directement depuis le navigateur. En outre, il y a une interface utilisateur alternative pour la documentation construite avec ReDoc. Pour rappel, ReDoc est un moteur de rendu open source pour les spécifications OpenAPI, permettant à un projet de publier son API sous forme de documentation interactive en ligne.

Vos utilisateurs pourront parcourir les méthodes, les paramètres et les résultats de l'API et visualiser des échantillons de code. ReDoc prend en charge les déclarations OpenAPI v3 avancées comme les objets imbriqués, le discriminateur, "one of", "any of", "all of" ou annulable, et les rappels qui ne sont pas correctement pris en charge par les outils concurrents.

Juste Python moderne

Tout est basé sur des déclarations standard de type Python 3.6 (grâce à Pydantic). Vous n'aurez pas d'apprendre de nouvelle syntaxe. FastAPI, c'est juste du Python moderne standard.

Support de l'éditeur

La documentation de FastAPI indique que tout le framework a été conçu pour être facile et intuitif à utiliser, toutes les propositions ont été testées sur plusieurs éditeurs avant même de commencer le développement, afin de garantir la meilleure expérience de développement possible. Toujours selon la documentation, dans la dernière enquête auprès des développeurs Python, il s'avère que la fonctionnalité la plus utilisée est l'autocomplétion. Ainsi, l'ensemble du framework FastAPI est conçu pour satisfaire à cette exigence. L'autocomplétion fonctionne partout. Vous aurez rarement besoin de revenir à la documentation.

Court

FastAPI dispose de valeurs par défaut raisonnables pour tout, avec des configurations optionnelles partout. Tous les paramètres peuvent être affinés pour faire ce dont vous avez besoin et pour définir l'API dont vous avez besoin.

Validation

Validation pour la plupart (ou la totalité ?) des types de données Python, y compris :

  • les objets JSON (dict) ;
  • les tableaux JSON (list) définissant les types d'objets ;
  • Les champs de type chaîne (str), définissant les longueurs min et max ;
  • Les nombres (int, float) avec des valeurs min et max, etc.

Validation pour des types plus exotiques, comme :

  • URL.
  • Email ;
  • UUID ;
  • etc.

Selon la documentation de FastAPI, toute la validation est assurée par la Pydantic, et est bien établie et robuste.

Sécurité et authentification

FastAPI a une sécurité et une authentification intégrées, sans aucun compromis avec les bases de données ou les modèles de données. Tous les schémas de sécurité définis dans OpenAPI, y compris :

  • HTTP Basic ;
  • OAuth2 (également avec les jetons JWT). Consultez le tutoriel sur OAuth2 avec JWT.

Les clés API :

  • en-têtes ;
  • paramètres d'interrogation ;
  • cookies ;
  • etc.

À cela s'ajoutent toutes les fonctions de sécurité de Starlette (y compris les cookies de session). Tous ces outils et composants sont réutilisables et faciles à intégrer dans vos systèmes, magasins de données, bases de données relationnelles et NoSQL, etc.

Injection de dépendance

Selon la documentation, FastAPI comprend un système d'injection de dépendance extrêmement facile à utiliser, mais extrêmement puissant, avec les caractéristiques suivantes :

  • les dépendances peuvent avoir des dépendances, créant ainsi une hiérarchie ou un "arbre" des dépendances ;
  • le tout est géré automatiquement par le framework ;
  • toutes les dépendances peuvent demander des données à partir de requêtes et augmenter les contraintes de fonctionnement du chemin et la documentation automatique ;
  • validation automatique même pour les paramètres d'opération du chemin définis dans les dépendances ;
  • prise en charge de systèmes complexes d'authentification des utilisateurs, de connexions à des bases de données, etc. ;
  • aucun compromis avec les bases de données, les frontaux, etc. Toutefois, il permet une intégration facile avec tous ces systèmes ;
  • FastAPI accepte un nombre illimité de "plug-ins".

Caractéristiques héritées de Starlette

La documentation indique FastAPI est entièrement compatible avec, et basé sur Starlette. Ainsi, tout code Starlette supplémentaire que vous avez fonctionnera également. FastAPI est en fait une sous-classe de Starlette. Donc, si vous connaissez ou utilisez déjà Starlette, la plupart des fonctionnalités fonctionneront de la même manière. Avec FastAPI, vous obtenez toutes les fonctionnalités de Starlette (car FastAPI n'est que Starlette sous stéroïdes) :
  • des performances très impressionnantes, au même titre que NodeJS et Go ;
  • prise en charge de WebSocket ;
  • prise en charge de GraphQL ;
  • tâches d'arrière-plan en cours de traitement ;
  • événements de démarrage et d'arrêt ;
  • client de test construit sur demande ;
  • CORS, GZip, fichiers statiques, réponses en streaming ;
  • prise en charge des sessions et des cookies ;
  • couverture de test à 100 %.

Source : FastAPI

Et vous ?

Que pensez-vous du framework Web Python FastAPI ?
A-t-il une chance de devenir le standard dans la construction d'API Python ?
A-t-il les atouts nécessaires pour concurrencer les frameworks Web Python comme Flask et Django ?

Voir aussi

Django 3.1 est disponible, compatible avec Python 3.6, 3.7 et 3.8 et introduit JSONField pour tous les backends de base de données supportés

Python : Flask passe à la version 1.0, le microframework de développement web se dote de nouvelles fonctionnalités

Introduction à Python 3 et au framework web Flask par l'exemple, un cours complet de Serge Tahé

JetBrains PyCharm : Création d'une API à l'aide de Flask-RESTful et du client HTTP PyCharm, un tutoriel de Ernst Haagsman

Une erreur dans cette actualité ? Signalez-le nous !

Avatar de Pyramidev
Expert confirmé https://www.developpez.com
Le 02/02/2021 à 18:42
FastAPI est un framework tout jeune. La première release date du 8 décembre 2018.
La première fois que j'en ai entendu parler, c'était le 18 décembre 2020 car un internaute avait posé une question dessus dans le forum Python.

Alors, j'avais quelques recherches et j'étais tombé sur plusieurs articles qui en disent beaucoup de bien, par exemple :
https://amitness.com/2020/06/fastapi-vs-flask/
https://towardsdatascience.com/fasta...i=30a115c555e6

Mais je n'ai pas testé moi-même FastAPI. Si quelqu'un sur ce forum a un témoignage concret à apporter, ce serait intéressant.

Par contre, j'ai pu tester Pydantic sur lequel se base FastAPI pour la validation.
Concrètement, j'ai utilisé les modèles de Pydantic dans le cadre du parsing de JSON et de YAML. Cela permet de définir le format de manière déclarative et d'avoir, en sortie du parsing, un objet statiquement typé dont les contraintes du type sont celles vérifiées par le parsing. C'est pratique quand on veut écrire du code à la fois concis et statiquement typé.
Cependant, attention, par défaut, quand un input est incorrect, le comportement par défaut de Pydantic est malheureusement d'essayer de convertir l'input vers le bon format au lieu de le rejeter directement. Pour éviter cela, il faut bien faire attention à utiliser les types stricts (StrictStr, StrictInt, etc.) et à interdire les champs en trop avec extra=Extra.forbid (documenté ici).

FastAPI s'appuie aussi sur les modèles de Pydantic, donc la même prudence s'applique.
1  0