Les API RESTful sont essentielles au développement moderne, permettant à différents systèmes de communiquer de manière efficace et évolutive. Python, avec son framework Flask, propose une approche simple et puissante pour créer des API. Dans ce guide, nous explorerons comment créer une API RESTful à l'aide de Flask, couvrant tout, des bases à l'authentification et à la consommation avec les clients HTTP.
Qu'est-ce qu'une API RESTful ?
Avant de commencer avec le code, il est important de comprendre ce qu'est une API RESTful. L'API (Application Programming Interface) est un ensemble de règles qui permettent à un logiciel de communiquer avec un autre. Le style REST (Representational State Transfer) définit un ensemble de principes que l'API doit suivre :
-
Client-Serveur : Séparation entre le client (qui consomme l'API) et le serveur (qui fournit les données).
-
Apatride : Chaque demande faite par le client doit contenir toutes les informations nécessaires au traitement du serveur.
-
Cacheable : les réponses de l'API peuvent être mises en cache pour améliorer les performances.
-
Interface uniforme : La communication entre le client et le serveur doit être effectuée de manière standardisée, en utilisant des méthodes HTTP telles que GET, POST, PUT et DELETE.
Création d'une API RESTful avec Flask
Nous allons maintenant créer une API simple qui gère une liste d'utilisateurs. L'API vous permettra d'ajouter, de modifier, d'afficher et de supprimer des utilisateurs.
1. Installation du flacon
Tout d’abord, assurez-vous que Flask est installé. Sinon, vous pouvez l'installer en utilisant pip :
Copier après la connexion
2. Structure du projet
Notre projet aura la structure suivante :
1 2 3 4 | /api_flask
│
├── app.py
└── requirements.txt
|
Copier après la connexion
3. Configuration du flacon
Dans le fichier app.py, on commence par importer les bibliothèques nécessaires et configurer notre application Flask :
1 2 3 4 5 6 7 8 9 | from flask import Flask, jsonify, request
app = Flask(__name__)
# Dados simulados
users = [
{ 'id' : 1, 'name' : 'Alice' , 'email' : 'alice@example.com' },
{ 'id' : 2, 'name' : 'Bob' , 'email' : 'bob@example.com' }
]
|
Copier après la connexion
4. Création de points de terminaison
Maintenant, créons nos points de terminaison pour les utilisateurs afficher, ajouter, mettre à jour et supprimer.
4.1. Point de terminaison pour répertorier les utilisateurs
Nous utiliserons la méthode GET pour lister tous les utilisateurs :
1 2 3 | @app.route( '/users' , methods=[ 'GET' ])
def get_users():
return jsonify(users), 200
|
Copier après la connexion
4.2. Point de terminaison pour obtenir un utilisateur spécifique
Nous utiliserons la méthode GET avec l'ID utilisateur pour obtenir les détails d'un utilisateur spécifique :
1 2 3 4 5 6 7 | @app.route( '/users/<int:user_id>' , methods=[ 'GET' ])
def get_user(user_id):
user = next((user for user in users if user[ 'id' ] == user_id), None)
if user:
return jsonify(user), 200
else :
return jsonify({ 'message' : 'User not found' }), 404
|
Copier après la connexion
4.3. Point de terminaison pour créer un nouvel utilisateur
La méthode POST sera utilisée pour ajouter un nouvel utilisateur. Le client enverra les données au format JSON.
1 2 3 4 5 6 7 8 9 10 | @app.route( '/users' , methods=[ 'POST' ])
def create_user():
data = request.get_json()
new_user = {
'id' : len(users) + 1,
'name' : data[ 'name' ],
'email' : data[ 'email' ]
}
users.append(new_user)
return jsonify(new_user), 201
|
Copier après la connexion
4.4. Point de terminaison pour mettre à jour un utilisateur
Ici, nous utilisons la méthode PUT pour mettre à jour les données d'un utilisateur existant :
1 2 3 4 5 6 7 8 9 10 | @app.route( '/users/<int:user_id>' , methods=[ 'PUT' ])
def update_user(user_id):
data = request.get_json()
user = next((user for user in users if user[ 'id' ] == user_id), None)
if user:
user[ 'name' ] = data[ 'name' ]
user[ 'email' ] = data[ 'email' ]
return jsonify(user), 200
else :
return jsonify({ 'message' : 'User not found' }), 404
|
Copier après la connexion
4.5. Point de terminaison pour supprimer un utilisateur
Nous utilisons la méthode DELETE pour supprimer un utilisateur :
1 2 3 4 5 | @app.route( '/users/<int:user_id>' , methods=[ 'DELETE' ])
def delete_user(user_id):
global users
users = [user for user in users if user[ 'id' ] != user_id]
return jsonify({ 'message' : 'User deleted' }), 200
|
Copier après la connexion
5. Exécution de l'API
Maintenant, lancez simplement notre application :
1 2 | if __name__ == '__main__' :
app.run(debug=True)
|
Copier après la connexion
En exécutant le fichier app.py, notre API sera disponible sur http://127.0.0.1:5000/users.
6. Authentification avec Flask
Pour ajouter une couche de sécurité à notre API, nous pouvons utiliser JWT (JSON Web Token). Avec JWT, nous pouvons garantir que seuls les utilisateurs authentifiés peuvent accéder à certains points de terminaison.
6.1. Installation de Flask-JWT-Extended
Installez l'extension requise :
1 | pip install Flask-JWT-Extended
|
Copier après la connexion
6.2. Configuration de JWT
Mettez à jour votre fichier app.py pour inclure l'authentification JWT :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | from flask_jwt_extended import JWTManager, create_access_token, jwt_required
app.config[ 'JWT_SECRET_KEY' ] = 'your-secret-key' # Troque pela sua chave secreta
jwt = JWTManager(app)
# Login para obter o token
@app.route( '/login' , methods=[ 'POST' ])
def login():
data = request.get_json()
if data[ 'username' ] == 'admin' and data[ 'password' ] == 'admin' :
access_token = create_access_token(identity={ 'username' : 'admin' })
return jsonify(access_token=access_token), 200
else :
return jsonify({ 'message' : 'Invalid credentials' }), 401
# Exemplo de endpoint protegido
@app.route( '/protected' , methods=[ 'GET' ])
@jwt_required()
def protected ():
return jsonify({ 'message' : 'Access granted to protected endpoint' }), 200
|
Copier après la connexion
Désormais, lors de l'accès au point de terminaison /protected, il sera nécessaire d'envoyer le jeton JWT dans l'en-tête de la requête pour authentifier l'utilisateur.
7. Consommer l'API avec le client HTTP
Pour consommer l'API, on peut utiliser des outils comme Postman ou des bibliothèques comme requests en Python.
Exemple de façon d'utiliser l'API à l'aide de requêtes :
1 2 3 4 5 | import requests
# Consumindo o endpoint de listagem de usuários
response = requests.get( 'http://127.0.0.1:5000/users' )
print (response.json())
|
Copier après la connexion
Conclusion
Créer une API RESTful avec Flask est simple et flexible. Flask propose un cadre minimaliste qui peut être étendu pour inclure des fonctionnalités telles que l'authentification, la gestion des erreurs et d'autres couches de sécurité. En suivant les principes REST et les bonnes pratiques de développement, il est possible de créer des API efficaces et évolutives avec Python.
Vous pouvez désormais créer votre propre API RESTful avec Flask, en la personnalisant selon vos besoins et exigences.
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!