Share
Transfert d'état représentatif (REST) est un style de conception d'architecture de développement Web qui consiste à séparer logiquement vos ressources d'API afin de permettre un accès, une manipulation et une mise à l'échelle faciles. Les composants réutilisables sont écrits de manière à pouvoir être facilement gérés via des requêtes HTTP simples et intuitives qui peuvent être GET, POST, PUT, PATCH et DELETE (il peut y en avoir plus, mais ci-dessus sont les plus couramment utilisées).
Malgré ce à quoi il ressemble, REST ne commande pas de protocole ou de norme. Il définit simplement un style d'architecture logicielle pour l'écriture d'applications Web et d'API, et simplifie les interfaces à l'intérieur et à l'extérieur de l'application. Les API de service Web qui sont écrites de manière à suivre les principes REST sont appelées API RESTful..
Dans cette série de didacticiels en trois parties, je traiterai de différentes manières de créer des API RESTful en utilisant Flask comme infrastructure Web. Dans la première partie, nous expliquerons comment créer des API REST basées sur des classes qui ressemblent davantage à des bricolages (faites-le vous-même), c’est-à-dire que vous les implémenterez toutes vous-même sans utiliser d’extensions tierces. Dans les dernières parties de cette série, nous expliquerons comment tirer parti de diverses extensions Flask pour créer plus facilement des API REST plus efficaces..
Je suppose que vous avez une connaissance de base des meilleures pratiques de configuration de Flask et de l’environnement à l’aide de virtualenv, à suivre lors du développement d’une application Python..
Les packages suivants doivent être installés pour l'application que nous allons développer.
$ pip installer le flacon $ pip installer le flacon-sqlalchemy
Les commandes ci-dessus doivent installer tous les packages requis pour que cette application fonctionne..
Pour ce tutoriel, je vais créer une petite application dans laquelle je vais créer un modèle trivial pour Produit. Ensuite, je démontrerai comment nous pouvons écrire une API RESTful pour la même chose. Ci-dessous la structure de l'application.
flask_app / my_app / - __init__.py produit / - __init__.py // fichier vide - models.py - views.py - run.py
Je ne créerai pas d'interface pour cette application, car les points de terminaison des API RESTful peuvent être testés directement en effectuant des appels HTTP à l'aide de diverses autres méthodes..
depuis une bouteille importation Flacon depuis flask.ext.sqlalchemy import SQLAlchemy app = Flacon (__ name__) app.config ['SQLALCHEMY_DATABASE_URI'] = 'sqlite: ////tmp/test.db' db = SQLAlchemy (app) de mon_app.catalog .views import catalogue app.register_blueprint (catalogue) db.create_all ()
Dans le fichier ci-dessus, l'application a été configurée avec l'initialisation des extensions et enfin la création de la base de données. La dernière instruction crée une nouvelle base de données à l’emplacement indiqué SQLALCHEMY_DATABASE_URI si une base de données n'existe pas déjà à cet emplacement, sinon l'application sera chargée avec la même base de données.
depuis my_app import db class Produit (db.Model): id = db.Column (db.Integer, primary_key = True) name = db.Column (db.String (255)) price = db.Column (db.Float (asdecimal) = True)) def __init __ (self, name, price): self.name = name self.price = price def __repr __ (self): return ''% self.id
Dans le fichier ci-dessus, j'ai créé un modèle très trivial pour stocker le nom et le prix d'un Produit. Cela va créer une table dans SQLite correspondant aux détails fournis dans le modèle.
Accentsconagua
importer json de la demande d'importation de flacon, jsonify, Blueprint, abandonner de flask.views importer MethodView de my_app import db, app de my_app.catalog.models importer Product catalog = Blueprint ('catalog', __name__) @ catalog.route ('/' ) @ catalog.route ('/ home') def home (): retourne "Bienvenue dans le catalogue". Classe ProductView (MethodView): def get (self, id = None, page = 1): sinon id: products = Product.query.paginate (page, 10) .items res = pour le produit dans les produits: res [product .id] = 'name': product.name, 'price': str (product.price), else: product = product.query.filter_by (id = id) .first () si ce n'est pas product: abort (404 ) res = 'name': product.name, 'price': str (product.price), retourne jsonify (res) def post (self): name = request.form.get ('name') price = request .form.get ('price') product = Produit (nom, prix) db.session.add (product) db.session.commit () renvoie jsonify (product.id: 'name': product.name, ' price ': str (product.price),) def put (auto, identifiant): # Met à jour l'enregistrement pour l'identifiant fourni # avec les détails fournis. return def delete (self, id): # Supprime l'enregistrement correspondant à l'identifiant fourni. return product_view = ProductView.as_view ('product_view') app.add_url_rule ('/ product /', view_func = product_view, methods = ['GET', 'POST']) app.add_url_rule ('/ product /', view_func = product_view, methods = [' GET ']) Le noeud majeur de ce tutoriel est traité dans le fichier ci-dessus. Flask fournit un utilitaire appelé vues enfichables, qui vous permet de créer des vues sous la forme de classes au lieu de fonctions. Répartition basée sur la méthode (MethodView) est une implémentation de vues connectables qui vous permet d’écrire des méthodes correspondant aux méthodes HTTP en minuscules. Dans l'exemple ci-dessus, j'ai écrit des méthodes obtenir() et poster() correspondant à HTTP OBTENIR et POSTER respectivement.
Le routage est également mis en œuvre de manière différente, dans les dernières lignes du fichier ci-dessus. Nous pouvons spécifier les méthodes qui seront supportées par une règle particulière. Tout autre appel HTTP serait rencontré par Erreur 405 Méthode non autorisée.
Pour exécuter l'application, exécutez le script run.py. Le contenu de ce script est:
depuis l'application d'importation my_app app.run (debug = True)
Maintenant, exécutez simplement depuis la ligne de commande:
$ python run.py
Pour vérifier si l'application fonctionne, lancez http://127.0.0.1:5000/ dans votre navigateur, et un simple écran avec un message de bienvenue devrait vous accueillir..
Pour tester cette API, nous pouvons simplement faire des appels HTTP en utilisant l’une des nombreuses méthodes disponibles. Les appels GET peuvent être effectués directement via le navigateur. Les appels POST peuvent être effectués à l'aide d'une extension Chrome telle que Postman ou à partir de la ligne de commande à l'aide de boucle, ou nous pouvons utiliser Python demandes bibliothèque pour faire le travail pour nous. Je vais utiliser la bibliothèque de demandes ici à des fins de démonstration.
Faisons un OBTENIR appelez d'abord pour vous assurer que nous n'avons encore aucun produit créé. Selon la conception de l'API RESTful, un appel get qui ressemble à quelque chose comme /produit/ devrait énumérer tous les produits. Ensuite, je créerai quelques produits en faisant POSTER appels à /produit/ avec quelques données. Puis un OBTENIR appeler pour /produit/ devrait énumérer tous les produits créés. Pour récupérer un produit spécifique, un OBTENIR appeler pour /produit/ devrait faire le travail. Vous trouverez ci-dessous un exemple de tous les appels pouvant être effectués à l'aide de cet exemple..
demandes $ pip install $ python >>> demandes d'importation >>> r = requests.get ('http: // localhost: 5000 / product /') >>> r.json () >>> r = demandes. post ('http: // localhost: 5000 / product /', data = 'name': 'iPhone 6s', 'price': 699) >>> r.json () u'1 ': u 'price': u'699.0000000000 ', u'name': u'iPhone 6s ' >>> r = requests.post (' http: // localhost: 5000 / product / ', data = ' name ': 'iPad Pro', 'price': 999) >>> r.json () u'2 ': u'price': u'999.0000000000 ', u'name': u'iPad Pro ' >> r = requests.get ('http: // localhost: 5000 / product /') >>> r.json () u'1 ': u'price': u'699.0000000000 ', u'name' : u'iPhone 6s ', u'2': u'price ': u'999.0000000000', u'name ': u'iPad Pro' >>> r = requests.get ('http: // localhost: 5000 / product / 1 ') >>> r.json () u'price': u'699.0000000000 ', u'name': u'iPhone 6s 'Dans ce tutoriel, vous avez vu comment créer des interfaces RESTful vous-même à l'aide de l'utilitaire de vues enfichables de Flask. C'est l'approche la plus flexible lors de l'écriture des API REST, mais elle nécessite beaucoup plus de code à écrire.
Il existe des extensions qui simplifient un peu la vie et automatisent énormément la mise en œuvre des API RESTful. Je vais couvrir ces derniers dans les deux prochaines parties de cette série de tutoriels.
