Comment créer des API RESTful avec Flask et Python

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 :

pip install Flask

2. Structure du projet

Notre projet aura la structure suivante :

/api_flask
│
├── app.py
└── requirements.txt

3. Configuration du flacon

Dans le fichier app.py, on commence par importer les bibliothèques nécessaires et configurer notre application Flask :

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'}
]

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 :

@app.route('/users', methods=['GET'])
def get_users():
    return jsonify(users), 200

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 :

@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

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.

@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

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 :

@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

4.5. Point de terminaison pour supprimer un utilisateur

Nous utilisons la méthode DELETE pour supprimer un utilisateur :

@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

5. Exécution de l'API

Maintenant, lancez simplement notre application :

if __name__ == '__main__':
    app.run(debug=True)

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 :

pip install Flask-JWT-Extended

6.2. Configuration de JWT

Mettez à jour votre fichier app.py pour inclure l'authentification JWT :

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

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 :

import requests

# Consumindo o endpoint de listagem de usuários
response = requests.get('http://127.0.0.1:5000/users')
print(response.json())

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!