Flask-RESTful et Swagger : meilleures pratiques pour créer des API RESTful dans les applications Web Python (partie 2)

Flask-RESTful et Swagger : meilleures pratiques pour créer des API RESTful dans les applications Web Python (partie 2)

Dans l'article précédent, nous avons exploré les meilleures pratiques pour créer des API RESTful à l'aide des pratiques Flask-RESTful et Swagger. Nous avons présenté les bases du framework Flask-RESTful et montré comment utiliser Swagger pour créer la documentation d'une API RESTful. Cet article continue d'approfondir ces sujets et présente des techniques et des pratiques plus avancées.

1. Utiliser l'autorisation et l'authentification

L'API RESTful doit être sécurisée, garantissant que seuls les utilisateurs autorisés peuvent y accéder. Pour y parvenir, nous devons utiliser l'autorisation et l'authentification. L'autorisation est le processus permettant de déterminer si un utilisateur est autorisé à accéder à une ressource. L'authentification est le processus de vérification de l'identité d'un utilisateur.

Flask-RESTful fournit une extension très utile, Flask-JWT. Flask-JWT peut nous aider à mettre en œuvre une authentification et une gestion des autorisations basées sur des jetons. Nous présentons ici brièvement comment utiliser Flask-JWT pour implémenter l'authentification par jeton.

from flask import Flask
from flask_jwt import JWT, jwt_required, current_identity
from werkzeug.security import safe_str_cmp

app = Flask(__name__)
app.config['SECRET_KEY'] = 'super-secret'

class User:
   def __init__(self, id, username, password):
      self.id = id
      self.username = username
      self.password = password

   def __str__(self):
      return "User(id='%s')" % self.id

users = [
   User(1, 'john', 'pass'),
   User(2, 'susan', 'pass'),
]

username_table = {u.username: u for u in users}
userid_table = {u.id: u for u in users}

def authenticate(username, password):
   user = username_table.get(username, None)
   if user and safe_str_cmp(user.password.encode('utf-8'), password.encode('utf-8')):
      return user

def identity(payload):
   user_id = payload['identity']
   return userid_table.get(user_id, None)

jwt = JWT(app, authenticate, identity)

@app.route('/protected')
@jwt_required()
def protected():
   return '%s' % current_identity

if __name__ == '__main__':
   app.run()

Dans le code ci-dessus, nous créons un objet JWT connecté à l'application Flask. L'objet JWT utilise SECRET_KEY de l'application Flask pour crypter et déchiffrer le jeton. Nous définissons également une classe d'utilisateurs et les informations sur les utilisateurs sont stockées dans la liste des utilisateurs.

Lors de la définition de la fonction d'authentification authenitcate, nous vérifions si le nom d'utilisateur existe et contient les informations de mot de passe. Si la vérification du mot de passe réussit, la fonction renvoie l'objet utilisateur. Lors de la définition de l'identité de la fonction d'identité, nous renvoyons l'objet utilisateur authentifié.

Sous le décorateur @app.route('/protected'), le décorateur @jwt_required() est utilisé pour protéger ce point de terminaison, garantissant que seuls les utilisateurs authentifiés et autorisés peuvent y accéder.

2. Implémentation du contrôle de version

Le contrôle de version est un concept très important car il rend l'interaction entre le client et le serveur stable et rétrocompatible. Une API doit maintenir autant que possible la compatibilité entre les clients et les serveurs, en particulier lorsque des modifications majeures sont apportées à l'API. Afin de réaliser le contrôle de version, nous devons introduire les numéros de version dans l'API.

Ce qui suit est une bonne pratique de gestion des versions :

from flask import Flask
from flask_restful import Resource, Api

app = Flask(__name__)
api = Api(app)
version = 'v1'

class HelloWorld(Resource):
    def get(self):
        return {'version': version, 'message': 'Hello World'}

api.add_resource(HelloWorld, f'/{version}/')

if __name__ == '__main__':
   app.run()

Dans le code ci-dessus, nous définissons la variable de version pour spécifier la version de l'API, puis utilisons la chaîne f-{version} dans le décorateur @app.route pour ajouter le numéro de version. Cela permet un contrôle de version et une meilleure compatibilité d’interface entre le client et le serveur.

3. Utilisez d'autres extensions

Flask-RESTful fournit de nombreux plugins d'extensibilité qui peuvent vous aider à créer des API RESTful plus rapidement et plus facilement. Voici quelques extensions couramment utilisées :

• Flask-CORS : résolvez le problème de l'accès inter-domaines des applications.
• Flask-Bcrypt : fournit une fonction de hachage de mot de passe bcrypt pour crypter les mots de passe.
• Flask-Migrate : fournit des fonctions de migration de données et de mise à niveau de base de données.
• Flask-Login : fournit une fonction de connexion utilisateur.

Ces extensions vous aident à créer des API RESTful plus efficacement.

Résumé

Cet article examine en profondeur les meilleures pratiques sur la façon d'utiliser Flask-RESTful et Swagger pour créer des API RESTful. Nous avons présenté comment utiliser l'autorisation et l'authentification pour garantir la sécurité des API, et comment implémenter le contrôle de version. Dans le même temps, afin de mieux créer des API, nous introduisons également certaines extensions Flask couramment utilisées. Ces pratiques vous aideront à créer des API RESTful plus rapidement et à rendre l'interaction entre le client et le serveur plus stable et rétrocompatible.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!