Construire sa première API avec Flask

Introduction

La construction d’une API RESTful robuste est essentielle pour les applications web modernes, car elle permet une communication transparente entre les services et les clients. Dans ce guide complet, vous apprendrez à créer, sécuriser et déployer votre première API à l’aide de Flask, un framework web Python à la fois léger et puissant. Nous allons créer un exemple d’API du monde réel qui sert des données de produits pour un scénario de commerce électronique et couvrir des fonctionnalités avancées telles que la gestion des erreurs, les opérations CRUD, l’intégration de bases de données, l’authentification, la modularisation avec Blueprints, la documentation de l’API, les tests et les stratégies de déploiement.

Importation des paquets requis

Pour garder notre code organisé et éviter les répétitions, nous commençons par importer les paquets nécessaires. Cela permet de s’assurer que tous les blocs de code suivants ont accès aux bibliothèques nécessaires.

# Importer les bibliothèques nécessaires au développement de l'API.
from flask import Flask, jsonify, request, abort

Création d’une API Flask de base avec des données d’exemple réelles

Nous allons créer une API de base qui fournit des données sur les produits pour un exemple de commerce électronique. Ceci inclut un point d’extrémité de bienvenue et un point d’extrémité /api/products qui renvoie une liste de produits.

Exemple d’API de base

# Initialiser l'application Flask.
app = Flask(__name__)

# Définir le point d'accès racine.
@app.route("/")
def index():
    return jsonify({"message": "Welcome to the Products API"})

# Définir un point de terminaison pour renvoyer une liste de produits.
@app.route("/api/products", methods=["GET"])
def get_products():
    # Échantillon de données de produits du monde réel.
    products = [
        {"id": 1, "name": "Wireless Mouse", "price": 29.99, "category": "Electronics"},
        {"id": 2, "name": "Bluetooth Headphones", "price": 59.99, "category": "Electronics"},
        {"id": 3, "name": "Coffee Maker", "price": 79.99, "category": "Home Appliances"},
        {"id": 4, "name": "Electric Kettle", "price": 39.99, "category": "Home Appliances"},
        {"id": 5, "name": "Smartphone Stand", "price": 19.99, "category": "Accessories"}
    ]
    return jsonify({"products": products})

if __name__ == "__main__":
    # Exécuter l'application sur le port 5000 avec le débogage activé.
    app.run(debug=True, port=5000)

Exécuter et tester l’API

Pour exécuter votre API Flask, exécutez votre script en utilisant par exemple python api.py. Veillez à ce que votre API s’exécute sur un port spécifique (par exemple, 5000) pour des raisons de cohérence. Par exemple:

if __name__ == "__main__":
    app.run(debug=True, port=5000)

Cette commande démarre le serveur de développement Flask sur le port 5000 avec le débogage activé.

Note

Une fois que votre API fonctionne, vous pouvez y accéder en visitant http://localhost:5000/ dans votre navigateur web.

Tester votre API

Vous pouvez tester votre API à l’aide d’outils tels que cURL ou Postman.

Utilisation de cURL:

curl http://127.0.0.1:5000/
curl http://127.0.0.1:5000/api/products

Utiliser Postman:
- Envoyez une requête GET à http://127.0.0.1:5000/api/products pour voir la réponse JSON avec les données du produit.

Gestion des erreurs et validation des entrées

Une gestion robuste des erreurs est cruciale pour une API de niveau production. Ici, nous ajoutons des gestionnaires d’erreurs et une validation des entrées pour nous assurer que notre API répond de manière appropriée aux entrées et aux erreurs inattendues.

Exemple de gestion des erreurs

from flask import abort

@app.route("/api/divide", methods=["GET"])
def divide():
    try:
        a = float(request.args.get("a", ""))
        b = float(request.args.get("b", ""))
        if b == 0:
            abort(400, description="Division by zero is not allowed.")
        return jsonify({"result": a / b})
    except ValueError:
        abort(400, description="Invalid input. Please provide numeric values.")

@app.errorhandler(400)
def bad_request(error):
    response = jsonify({"error": error.description})
    response.status_code = 400
    return response

Opérations CRUD

La gestion des ressources par le biais d’opérations CRUD (Create, Read, Update, Delete) est essentielle. Vous trouverez ci-dessous un exemple simple d’utilisation d’un magasin de données en mémoire pour la gestion des produits.

Exemple CRUD

# Magasin de données en mémoire pour les produits.
items = []

# Créer un nouveau produit.
@app.route("/api/items", methods=["POST"])
def create_item():
    data = request.get_json()
    items.append(data)
    return jsonify({"message": "Item created", "item": data}), 201

# Lire tous les produits.
@app.route("/api/items", methods=["GET"])
def get_items():
    return jsonify({"items": items})

# Mettre à jour un produit.
@app.route("/api/items/<int:item_id>", methods=["PUT"])
def update_item(item_id):
    data = request.get_json()
    if item_id < 0 or item_id >= len(items):
        abort(404, description="Item not found")
    items[item_id].update(data)
    return jsonify({"message": "Item updated", "item": items[item_id]})

# Supprimer un produit.
@app.route("/api/items/<int:item_id>", methods=["DELETE"])
def delete_item(item_id):
    if item_id < 0 or item_id >= len(items):
        abort(404, description="Item not found")
    deleted_item = items.pop(item_id)
    return jsonify({"message": "Item deleted", "item": deleted_item})

Intégration de la base de données

Pour les applications de production, l’intégration d’une base de données est essentielle. Flask peut facilement se connecter à des bases de données en utilisant un ORM comme SQLAlchemy.

Exemple d’intégration SQLAlchemy

# Configurer la base de données SQLite.
from flask_sqlalchemy import SQLAlchemy

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///api.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

# Définir un modèle simple pour les produits.
class Product(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(80), nullable=False)
    price = db.Column(db.Float, nullable=False)
    category = db.Column(db.String(80), nullable=False)

# Créer les tables de la base de données.
with app.app_context():
    db.create_all()

# Point de terminaison pour ajouter un produit à la base de données.
@app.route("/api/db/products", methods=["POST"])
def add_product():
    data = request.get_json()
    new_product = Product(name=data.get("name"), price=data.get("price"), category=data.get("category"))
    db.session.add(new_product)
    db.session.commit()
    return jsonify({"message": "Product added", "product": {"id": new_product.id, "name": new_product.name}}), 201

Authentification et autorisation

La sécurisation de votre API est essentielle. Vous trouverez ci-dessous un exemple de base utilisant JWT pour l’authentification.

Exemple d’authentification JWT

from flask_jwt_extended import JWTManager, create_access_token, jwt_required, get_jwt_identity

# Configurer JWT.
app.config["JWT_SECRET_KEY"] = "your-secret-key"
jwt = JWTManager(app)

@app.route("/api/login", methods=["POST"])
def login():
    username = request.json.get("username", None)
    password = request.json.get("password", None)
    # Pour la démonstration, utilisez un nom d'utilisateur et un mot de passe fixes.
    if username != "admin" or password != "password":
        abort(401, description="Invalid credentials")
    access_token = create_access_token(identity=username)
    return jsonify(access_token=access_token)

@app.route("/api/protected", methods=["GET"])
@jwt_required()
def protected():
    current_user = get_jwt_identity()
    return jsonify(logged_in_as=current_user)

Modularisation avec Blueprints

Pour les applications plus importantes, l’organisation de votre code en Blueprints permet de maintenir une structure propre. Les Blueprints vous permettent de regrouper des points d’extrémité connexes.

Exemple de schéma directeur

from flask import Blueprint

# Créez un plan directeur pour les points de terminaison liés aux produits.
products_bp = Blueprint('products', __name__)

@products_bp.route("/api/blueprint/products", methods=["GET"])
def blueprint_get_products():
    return jsonify({"products": items})

# Enregistrer le Blueprint avec l'application Flask.
app.register_blueprint(products_bp)

Documentation de l’API

La documentation interactive de l’API est essentielle pour les API de niveau de production. Des outils comme Flasgger peuvent générer automatiquement une documentation Swagger.

Exemple de configuration du flasheur

from flasgger import Swagger

# Initialiser Swagger pour la documentation de l'API.
swagger = Swagger(app)

@app.route("/api/docs")
def api_docs():
    return jsonify({"message": "Visit /apidocs for the interactive API documentation."})

Tests et déploiement

Tester l’API

Les tests automatisés garantissent la fiabilité de votre API. Par exemple, en utilisant pytest:

def test_index():
    response = app.test_client().get("/")
    assert response.status_code == 200
    assert b"Welcome" in response.data

Exécuter l’API

Exécutez votre application Flask sur le port 5000 en incluant la commande suivante:

if __name__ == "__main__":
    app.run(debug=True, port=5000)

Stratégies de déploiement

Pour le déploiement en production, envisagez les stratégies suivantes:

Utiliser un serveur WSGI de production:
Déployer votre application Flask à l’aide de Gunicorn:
```
gunicorn --bind 0.0.0.0:5000 your_script:app
```

Conteneurisation:
Utilisez Docker pour conteneuriser votre application. Par exemple, créer un fichier Docker:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
COPY . .
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "your_script:app"]

Remplacez your_script par le nom de votre fichier Python contenant l’application Flask.

Orchestration:
Pour la mise à l’échelle et la gestion, envisagez d’utiliser Kubernetes ou des outils d’orchestration similaires.

Organigramme de déploiement

flowchart LR
    A[Develop API] --> B[Write Tests]
    B --> C[Containerize with Docker]
    C --> D[Deploy with Gunicorn]
    D --> E[Orchestrate with Kubernetes]
    E --> F[Monitor & Scale]

Conclusion

En suivant ce guide complet, vous avez appris à construire une API RESTful de niveau production avec Flask en utilisant des données d’exemple du monde réel. Nous avons couvert la création d’API, la gestion des erreurs, les opérations CRUD, l’intégration de bases de données, l’authentification, la modularisation avec Blueprints, la documentation API, les tests et les stratégies de déploiement. Avec ces techniques, vous pouvez construire des API robustes, sécurisées et évolutives pour des applications du monde réel.

Plus d’informations

Bon codage et bonne construction et déploiement de votre API de niveau production avec Flask!

Explorer d’autres articles

Note

Voici d’autres articles de la même catégorie pour vous aider à approfondir le sujet.

Récupération de données sur le Web avec BeautifulSoup

Un guide pratique sur l'extraction de données à partir de sites web