Créons une API simple avec Flask : un guide étape par étape pour les développeurs

Flask est un microframework Python idéal pour la création d'applications Web et d'API. Sa simplicité et sa flexibilité en font un excellent choix pour les développeurs débutants et expérimentés. Dans cet article, nous verrons comment créer une API simple mais complète à l'aide de Flask.

Qu'est-ce qu'une API et pourquoi en avez-vous besoin ?

Une API (Application Programming Interface) est un ensemble de règles et d'outils qui permettent à différents programmes d'interagir les uns avec les autres. L'API RESTful utilise des requêtes HTTP pour effectuer des opérations CRUD (Create, Read, Update, Delete) sur les données. Les applications Web modernes sont souvent divisées en frontend et backend, où l'API sert de pont entre eux.

Préparation de l'environnement

Avant de commencer, nous devons installer Flask. Il est recommandé d'utiliser un environnement virtuel pour isoler les dépendances du projet :

python -m venv venv
source venv/bin/activate  # pour Linux/Mac
venv\Scripts\activate  # pour Windows
pip install flask

Création d'une API de base

Commençons par créer l'application Flask la plus simple. Créez un fichier app.py :

from flask import Flask, jsonify, request

app = Flask(__name__)

# Stockage temporaire des données
books = [
    {'id': 1, 'title': 'Clean code', 'author': 'Robert Martin'},
    {'id': 2, 'title': 'Python. To the heights of mastery', 'author': 'Luciano Ramallo'}
]

@app.route('/')
def home():
    return jsonify({'message': 'Welcome to the API library!'})

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

Lancez l'application avec la commande python app.py, et le serveur sera disponible à l'adresse http://127.0.0.1:5000/.

Mise en œuvre des opérations CRUD

Maintenant, ajoutons des points de terminaison pour travailler avec des livres.

Obtenir tous les livres (GET)

@app.route('/api/books', methods=['GET'])
def get_books():
    return jsonify({'books': books, 'count': len(books)})

Obtenir un livre par ID (GET)

@app.route('/api/books/<int:book_id>', methods=['GET'])
def get_book(book_id):
    book = next((book for book in books if book['id'] == book_id), None)
    if book:
        return jsonify(book)
    return jsonify({'error': 'Book not found'}), 404

Création d'un nouveau livre (POST)

@app.route('/api/books', methods=['POST'])
def create_book():
    if not request.json or 'title' not in request.json:
        return jsonify({'error': 'You must specify the name of the book'}), 400
    
    new_book = {
        'id': books[-1]['id'] + 1 if books else 1,
        'title': request.json['title'],
        'author': request.json.get('author', 'Unknown author')
    }
    books.append(new_book)
    return jsonify(new_book), 201

Mise à jour du livre (PUT)

@app.route('/api/books/<int:book_id>', methods=['PUT'])
def update_book(book_id):
    book = next((book for book in books if book['id'] == book_id), None)
    if not book:
        return jsonify({'error': 'Book not found'}), 404
    
    book['title'] = request.json.get('title', book['title'])
    book['author'] = request.json.get('author', book['author'])
    return jsonify(book)

Suppression du livre (DELETE)

@app.route('/api/books/<int:book_id>', methods=['DELETE'])
def delete_book(book_id):
    global books
    books = [book for book in books if book['id'] != book_id]
    return jsonify({'message': 'Book deleted successfully'})

Traitement des erreurs

Ajoutons des gestionnaires d'erreurs pour des réponses plus informatives :

@app.errorhandler(404)
def not_found(error):
    return jsonify({'error': 'Resource not found'}), 404

@app.errorhandler(500)
def internal_error(error):
    return jsonify({'error': 'Internal server error'}), 500

Test de l'API

Pour les tests, vous pouvez utiliser curl, Postman ou la bibliothèque Python requests :

# Obtenir tous les livres
curl http://127.0.0.1:5000/api/books

# Créer un nouveau livre
curl -X POST http://127.0.0.1:5000/api/books \
  -H "Content-Type: application/json" \
  -d '{"title":"Perfect Code","author":"Steve McConnell"}' Mettre à jour le livre
curl -X PUT http://127.0.0.1:5000/api/books/1 \
  -H "Content-Type: application/json" \
  -d '{"title":"Clean Code (new edition)"}'# Supprimer le livre
curl -X DELETE http://127.0.0.1:5000/api/books/2

Ajout de la validation

Pour une validation plus fiable des données, vous pouvez utiliser la bibliothèque flask-marshmallow :

from flask_marshmallow import Marshmallow

ma = Marshmallow(app)

class BookSchema(ma.Schema):
    class Meta:
        fields = ('id', 'title', 'author')

book_schema = BookSchema()
books_schema = BookSchema(many=True)

Connexion à la base de données

Pour les applications réelles, il vaut la peine d'utiliser une base de données. Installons Flask-SQLAlchemy :

pip install flask-sqlalchemy

Exemple de modèle de livre avec SQLAlchemy :

from flask_sqlalchemy import SQLAlchemy

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///books.db'
db = SQLAlchemy(app)

class Book(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(200), nullable=False)
    author = db.Column(db.String(100))
    
    def to_dict(self):
        return {
            'id': self.id,
            'title': self.title,
            'author': self.author
        }

Ajout de CORS

Si votre API est utilisée par une application front-end, vous devez configurer CORS :

pip install flask-cors

from flask_cors import CORS

CORS(app)

Sécurité et meilleures pratiques

Lors du développement d'une API, il est important de garder à l'esprit la sécurité. Utilisez des variables d'environnement pour stocker des données sensibles, implémentez l'authentification via des jetons JWT, limitez le nombre de requêtes (limitation de débit), validez toutes les données entrantes et utilisez HTTPS en production.

Il est également recommandé d'organiser la structure du projet en divisant le code en modules : créez des fichiers séparés pour les modèles, les routes et les configurations. Utilisez Blueprint pour regrouper les points de terminaison associés, ce qui rend le code plus maintenable et évolutif.

Déploiement de l'API

Pour déployer une application Flask en production, utilisez un serveur WSGI tel que Gunicorn :

pip install gunicorn
gunicorn -w 4 app:app

Plateformes de déploiement populaires : Heroku, DigitalOcean, AWS ou VPS traditionnel avec nginx en tant que proxy inverse.

Conclusion

Nous avons créé une API RESTful complète avec Flask, qui inclut toutes les opérations CRUD de base, la gestion des erreurs et la validation des données. Flask fournit une base minimale mais puissante pour créer des API de toute complexité. Les prochaines étapes peuvent être l'ajout d'une authentification, la documentation de l'API à l'aide de Swagger, la rédaction de tests unitaires et l'optimisation des performances.

Vous souhaitez approfondir vos connaissances en Python et en développement Web ?

Annexe Code propose des cours structurés sur Python, JavaScript, le travail avec les API et de nombreuses autres technologies. La formation est basée sur des exemples pratiques avec des explications étape par étape.

Rejoignez notre Chaîne Telegram, où vous trouverez des ressources utiles, des conseils de programmation et le soutien d'une communauté active de développeurs prêts à vous aider à n'importe quelle étape de votre apprentissage !