Apprenez à construire une API RESTful en utilisant Flask, Python et SQLite, couvrant la configuration, les opérations CRUD, l’intégration de bases de données et les meilleures pratiques pour l’organisation du code.
Introduction
Dans ce tutoriel, nous vous guiderons à travers le processus de création d’une API RESTful avec Flask et Python. Flask est un micro-cadre populaire pour la création d’applications web en Python, et les API RESTful sont une architecture standardisée pour créer des services web évolutifs et évolutifs.
Par conséquent, nous ne construirons pas un site web complet, qui nécessite de rendre des modèles HTML. Au lieu de cela, nous allons construire un code dorsal typique d’une application web Flask.
Conditions préalables
Avant de commencer, assurez-vous que vous avez installé les éléments suivants sur votre système :
- Python 3.x
pip(Installateur de conditionnement de l’emballage du CP)
Commençons.
1. Installation de Flask et Flask-RESTful
Avant d’installer Flask et ses dépendances, faisons un environnement virtuel et activons-le
$ python -m venv venv
$ source venv/bin/activate # activate it on Linux/macOS
$ \venv\Scripts\activate # activate on WindowsMaintenant, nous devons installer Flask et Flask-RESTful en utilisant pip. Ouvrez votre terminal ou l’invite de commande et lancez la commande suivante :
$ pip install Flask Flask-RESTful2. Création d’une application de base
Créer un nouveau fichier appelé app.pyet ajouter le code suivant:
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello():
return "Hello, World!"
if __name__ == '__main__':
app.run(debug=True)Ce code établit une application de base de flasque avec un seul itinéraire. Sauvegarder le fichier et lancer l’application avec la commande suivante:
$ python app.pyMaintenant, ouvrez votre navigateur web et visitez http://127.0.0.1:5000/. Vous devriez voir le message « Bonjour, Monde ».
3. Création d’une API RESTful avec Flask-RESTful
Maintenant que nous avons une application de base Flask, nous pouvons commencer à construire notre API RESTful. Modifier app.pyinclure le code suivant:
from flask import Flask, request
from flask_restful import Resource, Api
app = Flask(__name__)
api = Api(app)
class HelloWorld(Resource):
def get(self):
return {'message': 'Hello, World!'}
api.add_resource(HelloWorld, '/api')
if __name__ == '__main__':
app.run(debug=True)Ici, nous avons créé un HelloWorldressources qui hérite de Resourceet l’a ajouté à notre API sous le /apiterminal. Le get()Une méthode retourne un objet JSON contenant un message.
4. Test de l’API
Sauver les changements à app.pyet redémarrer l’application. Pour tester l’API, vous pouvez utiliser des outils comme curl, Postman, ou même votre navigateur web. Ouvrez votre navigateur web et visitez http://127.0.0.1:5000/api. Vous devez voir la réponse JSON suivante :
{
"message": "Hello, World!"
}5. Extension de l’API
Maintenant, élargissons notre API pour gérer des opérations plus complexes. Supposons que nous voulions créer une API pour gérer une liste de tâches. Mise à jour app.pyportant le code suivant:
from flask import Flask, request
from flask_restful import Resource, Api
app = Flask(__name__)
api = Api(app)
tasks = []
class TaskList(Resource):
def get(self):
return {'tasks': tasks}
def post(self):
task = request.get_json()
tasks.append(task)
return {'tasks': tasks}
api.add_resource(TaskList, '/tasks')
if __name__ == '__main__':
app.run(debug=True)
Maintenant, nous avons un TaskListune ressource à deux méthodes: get()pour la récupération de la liste des tâches et post()pour l’ajout d’une nouvelle tâche. La liste des tâches est conservée en mémoire sous la forme d’une simple liste Python.
6. Utilisation d’une base de données réelle (SQLite)
Dans cette étape, nous remplacerons la liste en mémoire par une base de données SQLite pour persister les tâches. SQLite est une base de données légère, sans serveur et autonome qui est facile à mettre en place et à utiliser.
Tout d’abord, installez l’extension Flask-SQLAlchemy pour faciliter le fonctionnement avec SQLAlchemy et SQLite:
$ pip install Flask-SQLAlchemyMise à jour app.pyportant le code suivant:
from flask import Flask, request
from flask_restful import Resource, Api
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///tasks.db'
db = SQLAlchemy(app)
api = Api(app)
class Task(db.Model):
id = db.Column(db.Integer, primary_key=True)
description = db.Column(db.String(200), nullable=False)
def __repr__(self):
return f'Task {self.id}: {self.description}'
db.create_all()
class TaskList(Resource):
def get(self):
tasks = Task.query.all()
task_list = [{'id': task.id, 'description': task.description} for task in tasks]
return {'tasks': task_list}
def post(self):
task_data = request.get_json()
if not task_data:
return {'message': 'No input data provided'}, 400
description = task_data.get('description')
if not description:
return {'message': 'Description is required'}, 400
new_task = Task(description=description)
db.session.add(new_task)
db.session.commit()
return {'message': 'Task added', 'task': {'id': new_task.id, 'description': new_task.description}}
api.add_resource(TaskList, '/tasks')
if __name__ == '__main__':
app.run(debug=True)Dans ce code mis à jour, nous avons ajouté le paquet Flask-SQLAlchemy et l’avons configuré pour utiliser un fichier de base de données SQLite nommé tasks.db. Nous avons créé un Taskmodèle avec une clé primaire et une description. Le db.create_all()fonction crée les tables de base de données si elles n’existent pas déjà.
Nous avons modifié le TaskListune ressource pour interagir avec la base de données SQLite. Le get()méthode récupère toutes les tâches de la base de données, et post()La méthode ajoute une nouvelle tâche à la base de données et engage les changements.
Lorsque vous faites une demande POST sans charge utile JSON valide, l’API renvoie un message d’erreur avec un code d’état 400, indiquant que la demande est incorrecte. De plus, le code vérifie si le champ de description est présent dans les données de demande et retourne un message d’erreur s’il manque.
Relancez l’application et testez l’API en utilisant votre outil préféré (par ex., curl, Postman, ou navigateur web). Les tâches devraient maintenant persister entre les sessions et être stockées dans le tasks.dbFichier de base de données SQLite.
7. Séparation du code en plusieurs fichiers
Dans les applications du monde réel, c’est une bonne pratique de séparer votre code en plusieurs fichiers pour maintenir une structure de projet propre et organisée. Cette modularité rend votre code plus facile à comprendre, à maintenir et à étendre.
Voici un exemple de la façon dont vous pourriez séparer le code de notre tutoriel en plusieurs fichiers :
config.py: Stockez les paramètres de configuration de votre application, tels que l’url de la base de données:
SQLALCHEMY_DATABASE_URI = 'sqlite:///tasks.db'models.py: Définir vos modèles de base de données et votre schéma:
from flask_sqlalchemy import SQLAlchemy
db = SQLAlchemy()
class Task(db.Model):
id = db.Column(db.Integer, primary_key=True)
description = db.Column(db.String(200), nullable=False) # nullable=False means that the column cannot be empty
def __repr__(self):
#Cette méthode est utilisée pour imprimer l'objet.
return f'Task {self.id}: {self.description}'resources.py: Définissez vos ressources et votre logique API :
from flask_restful import Resource
from flask import request
from models import Task, db
class TaskList(Resource):
def get(self):
#Obtenez toutes les tâches de la base de données.
tasks = Task.query.all()
#Convertissez les tâches en JSON et renvoyez une réponse.
task_list = [{'id': task.id, 'description': task.description} for task in tasks]
return {'tasks': task_list}
def post(self):
#Obtenez les données JSON de la requête.
task_data = request.get_json()
#Vérifiez si les données sont valides.
if not task_data:
return {'message': 'No input data provided'}, 400
description = task_data.get('description')
if not description:
return {'message': 'Description is required'}, 400
#Ajoutez la tâche à la base de données.
new_task = Task(description=description)
db.session.add(new_task)
#Validez la tâche dans la base de données.
db.session.commit()
#Renvoie un message à l'utilisateur.
return {'message': 'Task added', 'task': {'id': new_task.id, 'description': new_task.description}}app.py: Initialiser l’application, les ressources d’importation et définir les axes API :
from flask import Flask
from flask_restful import Api
from models import db
import config
from resources import TaskList
#Créez l'application Flask et le gestionnaire d'API Flask-RESTful.
app = Flask(__name__)
app.config.from_object(config)
#Initialisez l'objet Flask-SQLAlchemy.
db.init_app(app)
#Créez le gestionnaire d'API Flask-RESTful.
api = Api(app)
#Créez les points de terminaison.
api.add_resource(TaskList, '/tasks')
if __name__ == '__main__':
#Créez les tables de la base de données.
with app.app_context():
db.create_all()
#Démarrez le serveur Web de développement Flask.
app.run(debug=True)En séparant le code en différents fichiers, vous pouvez facilement gérer les composants de votre application et maintenir une structure de projet bien organisée. En outre, cette approche modulaire vous permet de réutiliser le code et d’adapter votre application plus efficacement.
Après avoir exécuté l’application, voici une demande POST que j’ai faite avec Postman :
Assurez-vous de choisir la méthode POST. Dirigez-vous vers l’onglet Corps, choisissez le brut et sélectionnez « JSON » dans le menu déroulant à droite des boutons radio.
Après avoir fait la demande POST à deux reprises, voici une demande GET :
Conclusion
Dans ce tutoriel, nous avons démontré comment créer une API RESTful en utilisant Flask, Python et SQLite. Nous avons montré comment utiliser Flask-RESTful pour construire l’API et la Flask-SQLAlchemy pour maintenir les données dans une base de données SQLite. Avec ces connaissances, vous pouvez créer des API plus complexes et puissantes pour vos applications.