Les interfaces de programmation d’applications (API) sont une partie essentielle de la construction et de la connexion de différents systèmes, permettant à vos applications de communiquer et d’échanger des données avec d’autres services.
Le développement d’un backend ne se limite pas à l’écriture d’API – il couvre également l’écriture de la logique commerciale côté serveur, la conception d’architectures système efficaces et d’autres fonctions clés. Lisez la suite pour apprendre à construire une API REST CRUD simple avec Flask (un framework Python léger) et la base de données Postgres.
Utiliser Flask pour construire des API backend
Flask est un framework Python léger qui fournit un certain nombre de fonctionnalités pour simplifier l’écriture d’API backend pour les clients web écrits à l’aide de différentes technologies telles que React et Angular.
Vous pouvez trouver le code source de ce projet dans ce dépôt GitHub.
Ce guide vous aidera à écrire une API REST qui met en œuvre les quatre opérations CRUD : créer, lire, mettre à jour et supprimer pour gérer les données des utilisateurs stockées dans une base de données Postgres.
La gestion d’une base de données Postgres
Pour commencer, rendez-vous sur le site d’ElephantSQL, une solution d’hébergement de bases de données basée sur le cloud qui fournit une plateforme pour créer et gérer des bases de données Postgres sur le cloud, inscrivez-vous et connectez-vous à la page de présentation de votre compte.
Cliquez sur le bouton Créer une nouvelle instance pour créer une nouvelle instance pour votre application.
Indiquez le nom de votre instance et sélectionnez le plan gratuit. Enfin, sélectionnez la région où l’instance sera hébergée pour terminer le processus d’installation.
Une fois l’instance créée, naviguez jusqu’à la page des paramètres et copiez le fichier URL de la base de donnéesvous l’utiliserez pour établir une connexion avec la base de données.
Mise en place d’un serveur Flask
Sur votre terminal, créez un dossier de projet et changez le répertoire actuel en ce nouveau dossier.
Avant d’installer Flask, vérifiez que vous utilisez la version 3.6+ de Python sur votre machine. Si ce n’est pas le cas, vous devez installer la dernière version de Python.
python --version
Ensuite, installez virtualenvpour créer un environnement de développement virtuel isolé.
pip install virtualenv
Ensuite, exécutez la commande ci-dessous pour créer un environnement virtuel.
virtualenv venv
Enfin, activez l’environnement virtuel.
# On Windows:
.\venv\Scripts\activate
# On Unix or MacOS:
source venv/bin/activate
Installer les paquets nécessaires
Dans le répertoire racine du dossier de votre projet, créez un fichier requirements.txt et ajoutez ces paquets.
flask
python-dotenv
psycopg2-binary
Ensuite, installez les paquets.
pip install -r requirements.txt
Le psycopg2-binaire est une bibliothèque Python qui agit comme un middleware, pour vous permettre d’établir des connexions avec votre base de données Postgres et d’effectuer diverses opérations sur la base de données.
Enfin, créez un fichier .env et collez l’URL de votre base de données.
DATABASE_URL= your database URL
Créer le serveur Flask
Enfin, créez un app.py dans le répertoire racine, et ajoutez le code ci-dessous.
import os
import psycopg2
from dotenv import load_dotenv
from flask import Flask, request, jsonify
load_dotenv()
app = Flask(__name__)
url = os.getenv("DATABASE_URL")
connection = psycopg2.connect(url)
@app.get("https://www.makeuseof.com/")
def home():
return "hello world"
Ce code met en place une instance de l’application Flask. Il crée ensuite une connexion à la base de données spécifiée dans la chaîne d’URL et, enfin, met en place une route d’accueil qui renvoie une chaîne en guise de réponse.
Créer l’API REST permettant les opérations CRUD
Maintenant, créez l’API REST qui met en œuvre les quatre opérations CRUD.
Créer une table de démonstration
Créer une table utilisateur dans la base de données.
Dans le fichier app.py, ajoutez le code ci-dessous.
CREATE_USERS_TABLE = "CREATE TABLE IF NOT EXISTS users (id SERIAL PRIMARY KEY, name TEXT);"
with connection:
with connection.cursor() as cursor:
cursor.execute(CREATE_USERS_TABLE)
- Ce code crée une nouvelle table PostgreSQL appelée utilisateurs avec deux colonnes.
- Il utilise la méthode de connexion psycopg2 pour établir la connexion avec la base de données et crée un nouvel objet curseur à l’aide de la méthode connexion.curseur qui est utilisée pour exécuter des requêtes SQL.
1. Définir la méthode POST
Créez la route post pour ajouter des données.
INSERT_USER_RETURN_ID = "INSERT INTO users (name) VALUES (%s) RETURNING id;"
@app.route("/api/user", methods=["POST"])
def create_user():
data = request.get_json()
name = data["name"]
with connection:
with connection.cursor() as cursor:
cursor.execute(INSERT_USER_RETURN_ID, (name,))
user_id = cursor.fetchone()[0]
return {"id": user_id, "name": name, "message": f"User {name} created."}, 201
- La chaîne de requête SQL définit une instruction SQL qui sera exécutée à l’aide de la fonction curseur.execute pour insérer une nouvelle ligne avec le nom d’un utilisateur dans la base de données utilisateurs dans la base de données. Il renvoie l’identifiant de l’utilisateur nouvellement créé.
- La fonction créer_utilisateur prend en paramètre un nom à stocker dans la base de données, tandis que la fonction curseur.fetchone est appelée pour récupérer l’identifiant de l’utilisateur nouvellement créé. Enfin, un dictionnaire contenant l’identifiant et le nom de l’utilisateur nouvellement créé, ainsi qu’un message indiquant que l’utilisateur a été créé avec succès, est renvoyé.
2. Définir la méthode GET
Définissez deux routes get : l’une pour récupérer toutes les données de la base de données, l’autre pour récupérer des données spécifiques de la base de données en fonction de l’identifiant.
SELECT_ALL_USERS = "SELECT * FROM users;"
@app.route("/api/user", methods=["GET"])
def get_all_users():
with connection:
with connection.cursor() as cursor:
cursor.execute(SELECT_ALL_USERS)
users = cursor.fetchall()
if users:
result = []
for user in users:
result.append({"id": user[0], "name": user[1]})
return jsonify(result)
else:
return jsonify({"error": f"Users not found."}), 404
@app.route("/api/user/<int:user_id>", methods=["GET"])
def get_user(user_id):
with connection:
with connection.cursor() as cursor:
cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,))
user = cursor.fetchone()
if user:
return jsonify({"id": user[0], "name": user[1]})
else:
return jsonify({"error": f"User with ID {user_id} not found."}), 404
- Cette première route API gère les requêtes HTTP GET pour récupérer tous les utilisateurs de la base de données. Elle récupère tous les utilisateurs de la base de données et renvoie les résultats au format JSON dans la réponse.
- Cette deuxième route API gère les requêtes HTTP GET pour récupérer les données d’un utilisateur spécifique dans la base de données. Elle prend en compte l’élément ID de l’utilisateur comme paramètre, récupère les données de l’utilisateur dans la base de données et renvoie les résultats au format JSON dans la réponse.
3. Définir la méthode PUT
Créez la route put pour mettre à jour les données stockées dans la base de données.
@app.route("/api/user/<int:user_id>", methods=["PUT"])
def update_user(user_id):
data = request.get_json()
name = data["name"]
with connection:
with connection.cursor() as cursor:
cursor.execute(UPDATE_USER_BY_ID, (name, user_id))
if cursor.rowcount == 0:
return jsonify({"error": f"User with ID {user_id} not found."}), 404
return jsonify({"id": user_id, "name": name, "message": f"User with ID {user_id} updated."})
- La route update_user prend le paramètre ID de l’utilisateur en entrée et l’utilise pour mettre à jour le nom de l’utilisateur spécifié dans la base de données.
- Si l’opération de mise à jour réussit, elle renvoie un objet JSON avec l’ID et le nom de l’utilisateur mis à jour, ainsi qu’un message de réussite dans la réponse.
4. Définir la méthode DELETE
Implémenter la route delete pour supprimer les données stockées d’un utilisateur spécifique dans la base de données.
@app.route("/api/user/<int:user_id>", methods=["DELETE"])
def delete_user(user_id):
with connection:
with connection.cursor() as cursor:
cursor.execute(DELETE_USER_BY_ID, (user_id,))
if cursor.rowcount == 0:
return jsonify({"error": f"User with ID {user_id} not found."}), 404
return jsonify({"message": f"User with ID {user_id} deleted."})
- Cette route API gère la fonctionnalité de suppression d’un utilisateur spécifique de la base de données sur la base de son ID. Si l’utilisateur n’est pas trouvé, elle renvoie un code d’état 404 avec un message d’erreur. Cependant, si l’opération de suppression est réussie, elle renvoie un objet JSON avec un message de réussite dans la réponse.
Écrire des API REST avec Flask
Ce guide montre comment utiliser Flask et Postgres pour construire une API REST CRUD simple, ainsi que comment établir une connexion à une base de données et exécuter différentes requêtes SQL pour lire et écrire des données dans une base de données. Vous pouvez maintenant créer une API REST simple qui peut gérer les quatre opérations CRUD requises dans toute application web.
Que vous construisiez un simple blog ou une application web complexe, Flask et Postgres offrent de puissantes fonctionnalités et capacités nécessaires à la création d’un système backend robuste. Vous pouvez également utiliser d’autres technologies comme FastAPI et MongoDB pour créer des API RESTful.
