API REST Flask - Guide de configuration de votre application Flask

Dans cet article, nous nous familiariserons avec les API et les API REST, puis créerons plus tard notre propre application Flask REST API.

Qu'est-ce qu'une API ?

API ou Application Programming Interface fournit une interface pour interagir avec différentes applications. Grâce aux API, nous pouvons récupérer, traiter, et envoyer des données – valeurs à partir d'autres applications.

Prenons l'exemple d'une application Web. Un client envoie des données sous forme de requête, le serveur les traite ensuite, puis renvoie les données de réponse appropriées au client.

Tout ce processus d'interaction se fait via l'API. Examinons à nouveau cet exemple et voyons où se situe le rôle des API.

Par conséquent, ce que le client envoie est une API contenant les données de la requête au serveur. Le serveur le traite, puis renvoie une autre API contenant les données de réponse appropriées au client.

Opérateurs CRUD et méthodes HTTP

Lors de l'utilisation d'une API, le client peut envoyer des données de demande au serveur de plusieurs manières. Ces types sont appelés CRUD Opérations.

Chaque CRUD (Créer Récupérer Mettre à jour Supprimer ) est associé à une méthode HTTP.

Regardons-les maintenant :

• Méthode HTTP GET– Récupère des informations spécifiques (à des fins de visualisation) à partir du serveur.
• PUBLIER – Envoie/crée de nouvelles informations dans la base de données du serveur.
• METTRE – Modifie/met à jour les informations dans la base de données ou les ajoute si elles ne sont pas déjà présentes.
• SUPPRIMER – Supprime les informations de la base de données du serveur.

Bon, maintenant que nous connaissons les méthodes, comprenons quand utiliser chacune d'elles. Prenons l'exemple suivant :

Nous avons une base de données d'étudiants contenant des informations telles que Noms, Classe, Âge, etc.

• Pour voir la liste des étudiants – Utilisez GET HTTP méthode
• Pour ajouter une information sur un nouvel étudiant – Utilisez POST HTTP méthode
• Pour modifier certaines informations (Classe /Age) d'un étudiant - Utilisez PUT HTTP méthode
• Pour supprimer les informations d'un étudiant de la base de données - Utilisez le SUPPRIMER HTTP méthode

Qu'est-ce qu'une API REST ?

A REST (Transfert d'état représentatif ) L'API est similaire à l'API standard. Ici, lorsque nous envoyons une requête au serveur, contrairement à une API qui répond avec des données, l'API REST répond avec des  ressources.

Ressources API REST

Maintenant, quelles sont les ressources ??

Eh bien, les ressources sont des données, mais la façon dont nous les voyons change. Les ressources sont similaires à la programmation orientée objet. Comprenons-le avec l'exemple suivant :

Envisagez une vue Flask - "/Book/Book123"

Ici, le même View Endpoint peut effectuer 4 actions.

• OBTENIR Livre/Livre123 : Affiche les informations sur le "Book123. "
• PUBLIER Livre/Livre123  :Crée un nouveau livre, "Book123".
• METTRE Livre/Livre123  :met à jour/modifie les informations sur le livre "Book123".
• SUPPRIMER Livre/Livre123 : Supprime "Book123" de la base de données

Puisqu'une seule entité a plusieurs fonctionnalités (méthodes POO), elle peut être considérée comme une ressource de livre.

Par conséquent, l'interaction entre le client et le serveur ne se fait plus avec des demandes de point de terminaison individuelles mais avec des ressources (avec le même point de terminaison pour différentes actions)

Apatridie des API REST

Une autre caractéristique de l'API REST est son apatridie. Cela signifie qu'une fois que le serveur a terminé une action, il l'oublie.

Comprenons cela avec un exemple.

Considérez la ressource de livre que nous avons vue ci-dessus. Disons que j'envoie des données sur un livre - " Une brève histoire du temps ” par Stephen Hawkings en utilisant la méthode POST.

Le serveur ajoutera ces informations à la base de données, puis oubliera l'action. C'est la prochaine fois que j'utiliserai un GET demande de récupération du Livre ; le serveur n'aura aucune mémoire de l'action précédente de la méthode POST.

Le serveur ira d'abord à la base de données et cherchera le livre. Et une fois qu'il aura trouvé le Livre, il répondra avec ces données. Encore une fois, après avoir terminé l'action, il l'oubliera.

Utilisation de JSON dans l'interaction API client-serveur

Les API utilisent le format JSON pour accepter et les demandes de retour .

Autrement dit, le client envoie les données de la demande au serveur sous forme de texte JSON. De même, le serveur traite les données et renvoie à nouveau la réponse sous forme de texte JSON.

Par conséquent, l'ensemble du processus d'une application Web basée sur l'API REST est le suivant :

• L'utilisateur envoie les données de la requête au serveur au format JSON.
• Le serveur convertit d'abord le JSON dans un format lisible par Python.
• Ensuite, le serveur traite la requête et crée à nouveau les données de réponse au format JSON
• Ensuite, le modèle de page Web convertit la réponse JSON dans un format lisible par l'utilisateur et l'affiche sur la page Web.

Par conséquent, un véritable échange d'informations entre le côté client (FRONT-END) et le serveur (BACK-END) dans l'API se produit à l'aide de texte JSON.

Le format JSON est similaire à un dictionnaire Python :

{
    'student1':{
        'name':'XYZ',
        'age' : 21
    }
}

Installer POSTMAN

Postman est une plateforme de collaboration pour le développement d'API. Les fonctionnalités de Postman simplifient chaque étape de la création d'une API et rationalisent la collaboration afin que vous puissiez créer de meilleures API plus rapidement.

Cliquez ici pour télécharger POSTMAN. Une fois installé, il ressemblera à ceci :

OK, les codeurs ! Assez avec la lecture, commençons maintenant à construire notre API REST.

Construire une application API REST Flask

Dans cette section, nous allons construire une simple application API Book REST en utilisant le Flask RESTFul bibliothèque. Alors commençons !!

1. Installation de Flask_restful dans votre système

Pour installer le package Flask_RestFull, exécutez la commande pip :

pip install flask_restful

Maintenant qu'il est installé, passons à la partie Base de données

2. Codage des modèles de base de données à l'aide de SQLAlchemy

Ici, nous utiliserons la base de données SQLite pour stocker nos modèles. Pour les utiliser, installez d'abord flask_sqlalchemy

pip install flask_sqlalchemy

Créez maintenant un models.py fichier et ajoutez le code suivant

from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

class BookModel(db.Model):
    __tablename__ = 'books'

    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(80))
    price = db.Column(db.Integer())
    author = db.Column(db.String(80))

    def __init__(self, name, price, author):
        self.name = name
        self.price = price
        self.author = author 
    
    def json(self):
        return {"name":self.name, "price":self.price, "author":self.author}

Ici, le BookModel a un nom, un prix et des champs d'auteur. Les API étant en JSON, nous créons une méthode Object .json() pour renvoyer un objet livre JSON.

Nous devons d'abord instancier une instance de base de données pour créer le modèle de base de données. Consultez notre tutoriel SQLAlchemy si vous avez des doutes concernant SQLAlchemy.

Maintenant que nous avons nos modèles, codez maintenant l'application Flask principale.

3. Codage de l'application Flask

Pour l'API REST Flask, nous devons inclure une API(app) supplémentaire instance pour indiquer à Flask qu'il s'agit d'une application Web d'API REST.

from flask import Flask
from flask_restful import Api

app = Flask(__name__)

api = Api(app) #Flask REST Api code 

if __name__ == '__main__':
    app.run(host='localhost', port=5000)

Ensuite, nous devons donner des informations SQLite à SQLAlchemy et lier l'instance de base de données (formulaire models.py) avec ce fichier d'application.

Alors pour cela, ajoutez le code :

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///<db_name>.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

db.init_app(app)

Ici, remplacez avec le nom que vous voulez pour votre DB.

SQLALCHEMY_TRACK_MODIFICATIONS est maintenu Faux juste pour la simplicité.

La troisième ligne relie l'instance de base de données à l'application. Nous avons besoin du fichier DB en place pour que les utilisateurs de la page Web puissent l'utiliser. De plus, nous l'exigeons avant la première demande de l'utilisateur lui-même.

Donc pour créer le fichier on utilise la fonction :

@app.before_first_request
def create_table():
    db.create_all()

Ajoutez ceci sous les codes donnés ci-dessus eux-mêmes. D'accord avec cela en place, codez nos classes de ressources API REST Flask.

4. Ajouter une ressource de liste de livres

Cette ressource ferait ce qui suit :

• Méthode GET :Afficher la liste des livres dans la base de données
• Méthode POST :Ajouter une nouvelle information de livre dans la base de données

Ainsi, le code ressemblerait à :

class BooksList(Resource):
    def get(self):
        #get all objects from BookModel
        #return the JSON text of all objects
        pass
        
    def post(self):
        #convert the JSON data sent by the user to python-format
        #create a new bookModel object and send in the data
        #save to DB
        pass

Ainsi, le code devrait être capable d'effectuer les tâches écrites ci-dessus. Remplaçons maintenant les commentaires par le code réel :

class BooksList(Resource):
    def get(self):
        books = BookModel.query.all()
        return {'Books':list(x.json() for x in books)}

    def post(self):
        data = request.get_json()
        new_book = BookModel(data['name'],data['price'],data['author'])
        db.session.add(new_book)
        db.session.commit()
        return new_book.json(),201

Ici dans la méthode GET,

• Obtenir les livres présents dans la base de données à l'aide de BookModle.query.all()
• Afficher le texte JSON du livre un par un sous forme de liste

Dans la méthode POST,

• Convertissez les données JSON à l'aide de request.get_json()
• Créer et ajouter les nouvelles informations sur le livre à la base de données

C'est ça; enfin, nous devons mentionner le point de terminaison de l'URL pour la ressource BooksList

api.add_resource(BooksView, '/books')

5. Ajouter une ressource de livre

Maintenant, nous allons créer une ressource qui :

• Méthode GET :affiche uniquement un livre spécifique demandé par l'utilisateur
• Méthode PUT :modifiez les informations d'un livre en particulier. S'il n'est pas présent, créez-en un
• Méthode DELETE :supprimer le livre en question

Ici, le code ressemblerait à :

class Book(Resource):
    def get(self,name):
        #get the book with the name given by the user
        #if book exists, return it else return 404 not found 

    def put(self,name):
        #convert the JSON data sent by the user to python-format
        #Search if the book exists
        #if it exists, update it with the data given by the user 
        #if does not exists, create and add the book into DB

    def delete(self,name):
        #Search if the book exists in the DB
        #delete it

Le code doit pouvoir effectuer toutes les tâches ci-dessus. Ajoutez donc le code :

class Book(Resource):
    def get(self,name):
        book = BookModel.query.filter_by(name=name).first()
        if book:
            return book.json()
        return {'message':'book not found'},404

    def put(self,name):
        data = request.get_json()

        book = BookModel.query.filter_by(name=name).first()

        if book:
            book.price = data["price"]
            book.author = data["author"]
        else:
            book = BookModel(name=name,**data)

        db.session.add(book)
        db.session.commit()

        return book.json()

    def delete(self,name):
        book = BookModel.query.filter_by(name=name).first()
        if book:
            db.session.delete(book)
            db.session.commit()
            return {'message':'Deleted'}
        else:
            return {'message': 'book not found'},404

Ici dans la méthode GET,

• BookModel.query.filter_by(name=name).first() renvoie le premier livre qu'il obtient de la base de données. Il renvoie None, si rien avec le nom n'a été trouvé.
• Renvoie le texte JSON du livre s'il est trouvé. Ou bien renvoie 404

Dans la méthode PUT,

• Convertir les données JSON à l'aide de request.get_json()
• Recherchez le livre portant le nom.
• Si elles existent, remplacez les anciennes données par les nouvelles données envoyées
• Ou bien créez un nouvel objet Livre
• Ajoutez-le à la base de données

Dans la méthode DELETE,

• Obtenir le livre avec le nom donné par l'utilisateur
• Supprimez-le

C'est ça. Enfin, ajoutez le point de terminaison de l'URL pour cette ressource

api.add_resource(BookView,'/book/<string:name>')

Et nous avons terminé !!

Code final de l'application API Flask Rest

Par conséquent, l'application principale Flask combinée est donnée ci-dessous :

from flask import Flask,request
from flask_restful import Api, Resource, reqparse
from models import db, BookModel

app = Flask(__name__)

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///data.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

api = Api(app)
db.init_app(app)

@app.before_first_request
def create_table():
    db.create_all()


class BooksView(Resource):
    '''
    parser = reqparse.RequestParser()
    parser.add_argument('name',
        type=str,
        required=True,
        help = "Can't leave blank"
    )
    parser.add_argument('price',
        type=float,
        required=True,
        help = "Can't leave blank"
    )
    parser.add_argument('author',
        type=str,
        required=True,
        help = "Can't leave blank"
    )'''

    def get(self):
        books = BookModel.query.all()
        return {'Books':list(x.json() for x in books)}

    def post(self):
        data = request.get_json()
        #data = BooksView.parser.parse_args()

        new_book = BookModel(data['name'],data['price'],data['author'])
        db.session.add(new_book)
        db.session.commit()
        return new_book.json(),201


class BookView(Resource):
    '''
    parser = reqparse.RequestParser()
    parser.add_argument('price',
        type=float,
        required=True,
        help = "Can't leave blank"
        )
    parser.add_argument('author',
        type=str,
        required=True,
        help = "Can't leave blank"
        )'''

    def get(self,name):
        book = BookModel.query.filter_by(name=name).first()
        if book:
            return book.json()
        return {'message':'book not found'},404

    def put(self,name):
        data = request.get_json()
        #data = BookView.parser.parse_args()

        book = BookModel.query.filter_by(name=name).first()

        if book:
            book.price = data["price"]
            book.author = data["author"]
        else:
            book = BookModel(name=name,**data)

        db.session.add(book)
        db.session.commit()

        return book.json()

    def delete(self,name):
        book = BookModel.query.filter_by(name=name).first()
        if book:
            db.session.delete(book)
            db.session.commit()
            return {'message':'Deleted'}
        else:
            return {'message': 'book not found'},404

api.add_resource(BooksView, '/books')
api.add_resource(BookView,'/book/<string:name>')

app.debug = True
if __name__ == '__main__':
    app.run(host='localhost', port=5000)

Le models.py fichier :

from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

class BookModel(db.Model):
    __tablename__ = 'books'

    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(80))
    price = db.Column(db.Integer())
    author = db.Column(db.String(80))

    def __init__(self, name, price, author):
        self.name = name
        self.price = price
        self.author = author 
    
    def json(self):
        return {"name":self.name, "price":self.price, "author":self.author}

Exécutons maintenant notre serveur et vérifions-les à l'aide de POSTMAN.

Mise en œuvre de l'application Flask REST API à l'aide de POSTMAN

Exécutez le serveur et accédez à POSTMAN.

1. Ressource BooksList :méthode POST

Allez dans "/livres ” endpoint utilisant la méthode POST

Dans le corps, sélectionnez raw – JSON et ajoutez les données JSON dans le corps

{
	"name":"book1",
	"price":123,
	"author":"author1"
}

Appuyez sur envoyer

Le livre – livre1 est créé

2. Ressource BooksList :méthode POST

Allez dans "livres/ ” en utilisant la méthode GET et appuyez sur envoyer. Vous obtiendrez la liste des Livres de la BD

Comme nous n'avons que book1 , il n'affiche qu'un seul objet dans la liste.

3. Ressource du livre :méthode GET

Allez maintenant dans "/books/book1 ” en utilisant GET et appuyez sur envoyer

Vous voyez, il affiche les informations de Book1

4. Ressource de livre :méthode PUT

Allez dans "/livres/livre1 ” en utilisant la méthode PUT et dans le corps, ajoutez le JSON suivant.

{
	"price": 100,
	"author":"author123"
}

Étant donné que le nom est déjà envoyé via la demande d'URL, nous devons envoyer le prix et l'auteur JSON.

Appuyez sur envoyer

Le prix et les valeurs d'auteur ont changé !! Essayez également de les vérifier en utilisant la méthode GET.

5. Ressource de livre :méthode DELETE

Allez dans "/livres/livre1 ” en utilisant la méthode DELETE

Regarde, il est supprimé !

Conclusion

C'est ça les gars ! J'espère que vous avez acquis suffisamment de connaissances sur le framework Flask REST API. Essayez vous-mêmes les codes ci-dessus pour mieux comprendre.

À la prochaine !