Créer une API REST sécurisée avec FastAPI et PostgreSQL

Créer une API REST sécurisée avec FastAPI et PostgreSQL est une démarche essentielle pour les développeurs souhaitant offrir des services web robustes et performants. Grâce à l’alliance de FastAPI, un framework moderne et rapide, et PostgreSQL, une base de données relationnelle puissante, il est possible de concevoir des APIs à la fois fiables et efficaces. Cette approche permet d’intégrer des fonctionnalités de sécurité avancées telles que l’authentification et l’autorisation tout en garantissant une gestion optimale des données. Les caractéristiques de FastAPI facilitent également le développement grâce à sa documentation automatique et sa validation proactive des données, faisant de cet ensemble un choix privilégié pour la création d’APIs sécurisées.

Dans cet article, nous allons aborder la création d’une API REST sécurisée en utilisant le framework FastAPI et la base de données PostgreSQL. Nous explorerons les meilleures pratiques pour garantir la sécurité de l’API, ainsi que des exemples de code qui illustrent chaque étape. Grâce à sa rapidité, sa simplicité d’utilisation et sa documentation intégrée, FastAPI est un choix de plus en plus populaire pour le développement d’API modernes et efficaces.

Comprendre le fonctionnement de FastAPI

FastAPI est un framework de développement d’API qui utilise des annotations de type pour valider les données, garantissant ainsi que les entrées de l’utilisateur respectent les exigences de l’application. L’un des plus grands avantages de FastAPI est sa capacité à générer automatiquement une documentation interactive grâce à Swagger et ReDoc.

La validation des données est essentielle lors de la création d’API, car elle permet de s’assurer que les informations reçues correspondent aux attentes du système. Avec FastAPI, il n’est pas nécessaire d’écrire une logique de validation manuelle, ce qui permet de gagner du temps et de réduire les erreurs.

De plus, la possibilité de gérer les appels asynchrones permet d’améliorer les performances de l’API, notamment lors du traitement de plusieurs requêtes simultanément.

Initialiser un projet avec PostgreSQL

Pour commencer, vous devez installer et configurer PostgreSQL. Lancez votre base de données et créez un utilisateur ainsi qu’une base de données pour votre projet. Ensuite, vous pouvez intégrer SQLAlchemy avec FastAPI pour la manipulation des données. SQLAlchemy est un ORM (Object Relational Mapping) qui facilite les interactions entre Python et PostgreSQL.

Voici un exemple de code pour se connecter à PostgreSQL à l’aide de SQLAlchemy :

<!– wp:code {"content":"

from sqlalchemy import create_enginenfrom sqlalchemy.ext.declarative import declarative_basenfrom sqlalchemy.orm import sessionmakernnSQLALCHEMY_DATABASE_URL = "postgresql://user:password@localhost/db_name"nengine = create_engine(SQLALCHEMY_DATABASE_URL)nSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)nBase = declarative_base()n

« } –>

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

SQLALCHEMY_DATABASE_URL = "postgresql://user:password@localhost/db_name"
engine = create_engine(SQLALCHEMY_DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()

Remplacez user, password, et db_name par les informations relatives à votre base de données. Une fois votre connexion établie, vous pouvez commencer à définir vos modèles de données.

Mettre en place des modèles de données

Pour définir des modèles de données dans FastAPI, vous devez créer des classes qui hériteront de Base et définir les attributs correspondants aux colonnes dans votre base de données PostgreSQL. Voici un exemple de modèle d’utilisateur :

<!– wp:code {"content":"

from sqlalchemy import Column, Integer, Stringnfrom sqlalchemy.orm import relationshipnnclass User(Base):n    __tablename__ = "users"nn    id = Column(Integer, primary_key=True, index=True)n    username = Column(String, unique=True, index=True)n    email = Column(String, unique=True, index=True)n    password = Column(String)n

« } –>

from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import relationship

class User(Base):
    __tablename__ = "users"

    id = Column(Integer, primary_key=True, index=True)
    username = Column(String, unique=True, index=True)
    email = Column(String, unique=True, index=True)
    password = Column(String)

Les colonnes sont définies à l’aide d’instances de Column, et chaque colonne est associée à un type de données spécifique. Il est également conseillé de chiffrer le mot de passe avant de le stocker dans la base de données pour renforcer la sécurité.

Intégrer la sécurité avec JWT

La sécurité des API est un enjeu majeur. Pour garantir que seules les personnes autorisées puissent accéder à certaines ressources, l’utilisation de JSON Web Tokens (JWT) est une pratique courante. FastAPI facilite l’implémentation de l’authentification par JWT.

Pour cela, vous pouvez utiliser le module pyjwt afin de créer et vérifier des tokens. Voici un exemple de fonction pour créer un token JWT :

<!– wp:code {"content":"

import jwtnfrom datetime import datetime, timedeltanfrom fastapi import Depends, HTTPException, statusnnSECRET_KEY = "your_secret_key"nALGORITHM = "HS256"nndef create_jwt_token(data: dict):n    expire = datetime.utcnow() + timedelta(hours=1)n    to_encode = data.copy()n    to_encode.update({"exp": expire})n    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)n    return encoded_jwtn

« } –>

import jwt
from datetime import datetime, timedelta
from fastapi import Depends, HTTPException, status

SECRET_KEY = "your_secret_key"
ALGORITHM = "HS256"

def create_jwt_token(data: dict):
    expire = datetime.utcnow() + timedelta(hours=1)
    to_encode = data.copy()
    to_encode.update({"exp": expire})
    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
    return encoded_jwt

Assurez-vous de remplacer your_secret_key par une clé secrète unique et complexe. Utilisez cette fonction lors de la connexion d’un utilisateur afin de lui fournir un token valide.

Développer les routes de l’API

Après avoir établi les modèles de données et la sécurité avec JWT, il est temps de développer les endpoints de votre API. FastAPI permet de définir facilement des routes qui répondent à des requêtes HTTP spécifiques.

Voici un exemple d’endpoint pour créer un nouvel utilisateur :

<!– wp:code {"content":"

from fastapi import FastAPI, Dependsnfrom sqlalchemy.orm import Sessionnfrom .database import SessionLocalnnapp = FastAPI()nn@app.post("/users/")ndef create_user(user: UserCreate, db: Session = Depends(get_db)):n    db_user = User(username=user.username, email=user.email, password=hash_user_password(user.password))n    db.add(db_user)n    db.commit()n    db.refresh(db_user)n    return db_usern

« } –>

from fastapi import FastAPI, Depends
from sqlalchemy.orm import Session
from .database import SessionLocal

app = FastAPI()

@app.post("/users/")
def create_user(user: UserCreate, db: Session = Depends(get_db)):
    db_user = User(username=user.username, email=user.email, password=hash_user_password(user.password))
    db.add(db_user)
    db.commit()
    db.refresh(db_user)
    return db_user

À chaque fois qu’un nouvel utilisateur est créé, le mot de passe doit être haché avant d’être stocké. Utilisez une fonction comme hash_user_password pour garantir que les mots de passe ne soient jamais stockés en clair.

Validation des entrées de l’utilisateur

Il est essentiel de valider les données fournies par l’utilisateur avant de les insérer dans la base de données. FastAPI facilite cette validation grâce aux modèles Pydantic. Voici un exemple de modèle de création d’utilisateur :

<!– wp:code {"content":"

from pydantic import BaseModelnnclass UserCreate(BaseModel):n    username: strn    email: strn    password: strnn    class Config:n        orm_mode = Truen

« } –>

from pydantic import BaseModel

class UserCreate(BaseModel):
    username: str
    email: str
    password: str

    class Config:
        orm_mode = True

Le modèle ci-dessus garantit que l’utilisateur doit fournir un username, email, et password lors de la création d’un compte. FastAPI renverra automatiquement une erreur si les données ne respectent pas ces règles.

Tester l’API avec Swagger

Une des caractéristiques les plus appréciées de FastAPI est la documentation générée automatiquement. Lorsque vous démarrez votre application, vous pouvez accéder à l’interface Swagger UI à l’adresse /docs. Cela vous permet de tester vos endpoints directement depuis le navigateur.

Lorsque vous accédez à /docs, vous verrez tous vos endpoints répertoriés avec la possibilité de tester chaque route en envoyant des requêtes. Cela simplifie grandement le processus de test et de débogage.

Configurer le déploiement de l’API

Pour déployer votre API FastAPI, vous pouvez utiliser des serveurs comme Uvicorn ou Gunicorn. Uvicorn est spécialement conçu pour être léger et rapide, et il est souvent utilisé pour le développement d’API.

Pour exécuter votre application avec Uvicorn, utilisez la commande suivante :

<!– wp:code {"content":"

uvicorn main:app --host 0.0.0.0 --port 8000 --reloadn

« } –>

uvicorn main:app --host 0.0.0.0 --port 8000 --reload

Cela lancera votre API sur l’adresse http://127.0.0.1:8000. Utilisez l’option --reload pour que le serveur se recharge automatiquement lors de modifications du code source, facilitant ainsi le développement.

En suivant ces étapes, vous pouvez créer une API REST complexe, sécurisée et optimisée qui fonctionne avec FastAPI et PostgreSQL. N’hésitez pas à consulter des ressources supplémentaires pour approfondir vos compétences en développement d’API.

Comparaison des caractéristiques pour créer une API REST sécurisée avec FastAPI et PostgreSQL

Caractéristiques	Description
Authentification	Mise en œuvre de OAuth2 pour sécuriser les endpoints.
Gestion des utilisateurs	Utilisation de PostgreSQL pour stocker les informations d’utilisateurs de manière sécurisée.
Validation des données	Application de Pydantic pour assurer la validation des modèles de données.
Protection CSRF	Renseignement de jetons pour prévenir les attaques Cross-Site Request Forgery.
Chiffrement des données	Utilisation de SSL/TLS pour sécuriser les communications entre le client et le serveur.
Documentation automatique	Génération d’une documentation d’API via Swagger UI.
Gestion des erreurs	Utilisation des exceptions HTTP pour un retour clair en cas d’erreurs.
Routage asynchrone	Support nativement des appels asynchrones pour améliorer les performances.
Tests unitaires	Intégration d’outils pour effectuer des tests automatisés et assurer la qualité.

Les étapes pour une API REST sécurisée

Dans le paysage actuel du développement d’applications, la création d’une API REST sécurisée avec FastAPI et PostgreSQL s’avère crucial. FastAPI, grâce à sa vitesse et son support natif des appels asynchrones, permet de concevoir des applications très réactives. Associer ce framework léger à PostgreSQL, une base de données relationnelle robuste, confère à votre API une structure solide sur laquelle construire vos applications.

La sécurité est un aspect essentiel à ne pas négliger. Il est recommandé d’implémenter des mécanismes d’authentification tels que les tokens JWT, garantissant que seules les requêtes authentifiées puissent accéder à vos ressources. En parallèle, le cryptage des données sensibles et l’utilisation de HTTPS renforcent la protection contre les attaques.

Enfin, n’oubliez pas de suivre les bonnes pratiques lors de la conception de votre API. De la gestion des erreurs aux réponses cohérentes en passant par une documentation claire, chaque détail compte. L’application de ces principes vous permettra de créer une API à la fois performante et sécure, capable de répondre aux attentes croissantes des utilisateurs. Se concentrer sur ces éléments dès le départ vous aidera à bâtir une base solide pour vos futures applications.