Apprenez FastAPI avec un projet
Créez une application web complète avec FastAPI ! Des bases à l'authentification, bases de données et téléchargement de médias. Guide étape par étape sur un projet réel
Cet article décrit le processus de développement du backend d'une application de partage de photos et vidéos en utilisant le framework FastAPI. Le projet couvre le cycle complet de création d'une API, incluant les opérations de base sur les données, la connexion à une base de données, le traitement du téléchargement de fichiers et la mise en œuvre de l'authentification des utilisateurs. Une expérience de base avec le langage Python est supposée.
Introduction
L'objectif du projet est de créer une API complète pour une application permettant aux utilisateurs de télécharger et de visualiser des photos et des vidéos. Dans le cadre du développement, les concepts clés des applications web et des API seront abordés, ainsi que les aspects pratiques de la mise en œuvre avec des outils modernes.
Concepts clés des applications web et des API
URL, Chemins et Points d'accès (Endpoints)
URL (Uniform Resource Locator) est l'adresse d'une ressource sur le réseau. Elle se compose de plusieurs éléments :
- Schéma : Protocole de transfert de données (par exemple,
http,https). - Domaine : Nom du serveur ou adresse IP (par exemple,
example.com). - Chemin (Path) : Indique une ressource ou une page spécifique sur le serveur (par exemple,
/users/profile). Le chemin définit le point d'accès (endpoint) — le point d'entrée de l'API auquel le client accède.
Paramètres de requête (Query Parameters)
Les paramètres de requête sont ajoutés à l'URL après le signe point d'interrogation (?) et sont utilisés pour filtrer ou affiner les données. Ils représentent des paires clé-valeur séparées par une esperluette (&).
Exemple : /posts?category=technology&sort=date
Structure de la Requête et de la Réponse
L'interaction entre le client (par exemple, un navigateur web ou une application mobile) et le serveur se fait par le biais de requêtes et de réponses.
Requête (Request) :
- Méthode (HTTP Method) : Définit l'action que le client souhaite effectuer sur la ressource. Méthodes principales :
GET: Récupération de données.POST: Création d'une nouvelle ressource.PUT/PATCH: Mise à jour d'une ressource existante.DELETE: Suppression d'une ressource.
- Chemin (Path) : Le point d'accès de l'API.
- En-tête (Headers) : Contient les métadonnées de la requête, telles que le type de contenu, les informations d'authentification (par exemple, un jeton JWT).
- Corps (Body) : Contient les données envoyées au serveur (par exemple, données de formulaire, objet JSON). Utilisé avec les méthodes
POST,PUT,PATCH.
Réponse (Response) :
- Code d'état (Status Code) : Un nombre à trois chiffres indiquant le résultat du traitement de la requête. Les plus courants :
200 OK: Requête réussie.201 Created: Ressource créée avec succès.204 No Content: Requête réussie, mais pas de corps de réponse.400 Bad Request: Requête client incorrecte.401 Unauthorized: Authentification requise.403 Forbidden: Accès refusé.404 Not Found: Ressource introuvable.500 Internal Server Error: Erreur côté serveur.
- En-tête (Headers) : Métadonnées de la réponse, par exemple, le type de contenu.
- Corps (Body) : Données renvoyées par le serveur (souvent au format JSON).
Configuration du projet et installation des dépendances
Pour commencer, il est nécessaire d'initialiser le projet et d'installer les bibliothèques nécessaires. Il est recommandé d'utiliser le gestionnaire de paquets uv (ou pip).
-
Initialisation du projet :
uv init .Cette commande crée le fichier
pyproject.tomlpour la gestion des dépendances du projet. -
Installation des dépendances :
uv add fastapi uvicorn python-dotenv sqlalchemy fastapi-users imagekit-io aiosqlitefastapi: Le framework principal.uvicorn: Serveur ASGI pour exécuter les applications FastAPI.python-dotenv: Pour charger les variables d'environnement à partir d'un fichier.env.sqlalchemy: ORM pour travailler avec les bases de données.fastapi-users: Bibliothèque pour une implémentation rapide de l'authentification des utilisateurs.imagekit-io: SDK pour l'intégration avec le service ImageKit pour le traitement des fichiers multimédias.aiosqlite: Driver asynchrone pour travailler avec SQLite.
-
Variables d'environnement : Créez un fichier
.envà la racine du projet pour stocker les données sensibles, telles que les clés API ImageKit.IMAGEKIT_PRIVATE_KEY=votre_clé_privée IMAGEKIT_PUBLIC_KEY=votre_clé_publique IMAGEKIT_URL_ENDPOINT=votre_point_de_terminaison_urlIl est nécessaire de s'inscrire sur ImageKit et d'obtenir les clés correspondantes.
Bases de FastAPI
Création d'une instance d'application
Le fichier principal de l'application (par exemple, app/main.py ou app/app.py) commence par importer FastAPI et créer une instance de l'application.
# app/app.py
from fastapi import FastAPI
app = FastAPI()
Définition des points d'accès (Endpoints)
Les points d'accès sont définis à l'aide de décorateurs correspondant aux méthodes HTTP.
# app/app.py
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def read_root():
return {"message": "Hello, World!"}
@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str | None = None):
return {"item_id": item_id, "q": q}
@app.get("/"): Définit un point d'accès GET sur le chemin racine.@app.get("/items/{item_id}"): Définit un point d'accès GET avec un paramètre de cheminitem_id. FastAPI convertit automatiquementitem_idenintet effectue la validation.q: str | None = None: Définit un paramètre de requête optionnelqde typestr.
Lancement de l'application
L'application est lancée à l'aide du serveur ASGI uvicorn. Créez un fichier main.py pour lancer le serveur.
# main.py
import uvicorn
from app.app import app # Importe l'instance FastAPI depuis app/app.py
if __name__ == "__main__":
uvicorn.run(app, host="0.0.0.0", port=8000, reload=True)
Lancement :
uvicorn main:app --reload
ou
uv run main.py
Documentation automatique
FastAPI génère automatiquement une documentation interactive de l'API basée sur le code.
- Swagger UI :
/docs - ReDoc :
/redoc
Création de l'API : Fonctionnalités principales
Modèles de données et Schémas (Pydantic)
Pydantic est utilisé pour définir des schémas de données qui assurent la validation des données entrantes et sortantes.
# app/schemas.py
from pydantic import BaseModel
from typing import Optional
class PostBase(BaseModel):
title: str
content: str
class PostCreate(PostBase):
pass
class Post(PostBase):
id: int # Ou UUID si utilisé
class Config:
orm_mode = True # Pour travailler avec les modèles SQLAlchemy
Paramètres de chemin et de requête
- Paramètres de chemin : Segments dynamiques de l'URL.
@app.get("/posts/{post_id}") async def get_post(post_id: int): # Logique pour récupérer le post par ID return {"post_id": post_id} - Paramètres de requête : Paramètres optionnels ou obligatoires après le
?.@app.get("/posts") async def get_posts(limit: int = 10, skip: int = 0): # Logique pour récupérer la liste des posts avec filtrage return {"limit": limit, "skip": skip}
Corps de la requête (Request Body)
Pour envoyer des données dans le corps de la requête (par exemple, lors de la création d'un post), un schéma Pydantic est utilisé.
# app/app.py
from fastapi import FastAPI
from app.schemas import PostCreate, Post
from typing import List
app = FastAPI()
# Stockage temporaire des données (sera remplacé par une base de données)
posts_db = {}
post_id_counter = 1
@app.post("/posts", response_model=Post)
async def create_post(post: PostCreate):
global post_id_counter
new_post = Post(id=post_id_counter, title=post.title, content=post.content)
posts_db[post_id_counter] = new_post
post_id_counter += 1
return new_post
Typage des données de sortie
Spécifier le type de retour améliore la documentation et la validation.
# app/app.py
from app.schemas import PostCreate, Post
from typing import List
# ... (code précédent)
@app.post("/posts", response_model=Post)
async def create_post(post: PostCreate):
# ... (logique de création du post)
return new_post
@app.get("/posts", response_model=List[Post])
async def get_all_posts():
return list(posts_db.values())
Intégration avec la base de données (SQLAlchemy & AsyncIO)
Pour le stockage persistant des données, une base de données SQLite avec accès asynchrone est utilisée.
Configuration de la base de données
Créez un fichier app/db.py pour configurer la connexion et les modèles de données.
# app/db.py
from sqlalchemy import create_engine, Column, Integer, String, Text, DateTime, ForeignKey, Boolean
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.ext.asyncio import async_sessionmaker
from datetime import datetime
import uuid
from fastapi import Depends # Ajouté pour get_user_db
DATABASE_URL = "sqlite+aiosqlite:///./test.db"
# Création du moteur asynchrone
engine = create_async_engine(DATABASE_URL, echo=True)
# Création de la fabrique de sessions asynchrones
AsyncSessionLocal = async_sessionmaker(
autocommit=False,
autoflush=False,
class_=AsyncSession
)
# Classe de base pour les modèles déclaratifs
Base = declarative_base()
# Modèle de données pour un post
class Post(Base):
__tablename__ = "posts"
id = Column(Integer, primary_key=True, index=True) # Ou UUID
title = Column(String, index=True)
content = Column(Text)
created_at = Column(DateTime, default=datetime.utcnow)
user_id = Column(Integer, ForeignKey("users.id")) # Lien vers l'utilisateur
file_url = Column(String) # URL du fichier stocké
file_type = Column(String) # 'image' ou 'video'
file_name = Column(String) # Nom du fichier sur le stockage
user = relationship("User", back_populates="posts")
# Modèle de données pour l'utilisateur (pour FastAPI-Users)
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True, index=True) # Ou UUID
email = Column(String, unique=True, index=True)
hashed_password = Column(String)
is_active = Column(Boolean, default=True)
is_superuser = Column(Boolean, default=False)
is_verified = Column(Boolean, default=False)
posts = relationship("Post", back_populates="user")
# Fonction pour obtenir une session asynchrone
async def get_async_session() -> AsyncSession:
async with AsyncSessionLocal() as session:
yield session
# Fonction pour créer les tables
async def create_db_tables():
async with engine.begin() as conn:
await conn.run_sync(Base.metadata.create_all)
# Pour FastAPI-Users
from fastapi_users.db import SQLAlchemyUserDatabase
async def get_user_db(session: AsyncSession = Depends(get_async_session)):
yield SQLAlchemyUserDatabase(session, User)
Intégration avec FastAPI
Utilisez lifespan pour créer automatiquement les tables au démarrage de l'application.
# app/app.py
from fastapi import FastAPI, Depends, HTTPException, File, UploadFile, Form
from app.schemas import PostCreate, Post, UserCreate, UserRead, UserUpdate, PostWithUser # Importe les schémas utilisateurs et PostWithUser
from app.db import Post as PostModel, User as UserModel, get_async_session, create_db_tables, get_user_db # Importe les modèles BD
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select
from contextlib import asynccontextmanager
from typing import List, Optional
import shutil
import os
import uuid
# Import pour ImageKit
from imagekitio import ImageKit
from imagekitio.models.models import UploadFileRequestOptions
from dotenv import load_dotenv
load_dotenv() # Charge les variables d'environnement
# Initialisation d'ImageKit
imagekit = ImageKit(
private_key=os.getenv("IMAGEKIT_PRIVATE_KEY"),
public_key=os.getenv("IMAGEKIT_PUBLIC_KEY"),
url_endpoint=os.getenv("IMAGEKIT_URL_ENDPOINT")
)
# --- Authentification des utilisateurs (FastAPI-Users) ---
from fastapi_users import FastAPIUsers, BaseUserManager, UUID_ID
from fastapi_users.authentication import (
AuthenticationBackend,
BearerTransport,
JWTStrategy,
)
from fastapi_users.db import SQLAlchemyUserDatabase
# Clé secrète pour JWT (doit être robuste et stockée dans .env)
SECRET = os.getenv("JWT_SECRET_KEY", "votre_super_cle_secrete_ici") # Recommandé de générer une clé aléatoire
# Gestionnaire d'utilisateurs
class UserManager(BaseUserManager[UUID_ID, UserModel]):
reset_password_token_secret = SECRET
verification_token_secret = SECRET
async def get_user_manager(user_db: SQLAlchemyUserDatabase = Depends(get_user_db)):
yield UserManager(user_db)
# Transport pour les jetons (Bearer Token)
bearer_transport = BearerTransport(tokenUrl="auth/jwt/login")
# Stratégie JWT
def get_jwt_strategy() -> JWTStrategy:
return JWTStrategy(secret=SECRET, lifetime_seconds=3600) # Le jeton est valide pendant 1 heure
# Backend d'authentification
auth_backend = AuthenticationBackend(
name="jwt",
transport=bearer_transport,
get_strategy=get_jwt_strategy,
)
fastapi_users = FastAPIUsers[UserModel, UUID_ID](
get_user_manager, auth_backend
)
# Obtention de l'utilisateur actif actuel
current_active_user = fastapi_users.current_user(active=True)
# --- Gestionnaire de cycle de vie de l'application ---
@asynccontextmanager
async def lifespan(app: FastAPI):
await create_db_tables() # Crée les tables au démarrage
yield
app = FastAPI(lifespan=lifespan)
# --- Inclusion des routes d'authentification ---
app.include_router(
fastapi_users.get_auth_router(auth_backend), prefix="/auth/jwt", tags=["auth"]
)
app.include_router(
fastapi_users.get_register_router(UserRead, UserCreate), prefix="/auth", tags=["auth"]
)
app.include_router(
fastapi_users.get_reset_password_router(), prefix="/auth", tags=["auth"]
)
app.include_router(
fastapi_users.get_verify_router(), prefix="/auth", tags=["auth"]
)
app.include_router(
fastapi_users.get_users_router(), prefix="/users", tags=["users"]
)
# --- Points d'accès de l'API ---
# Obtention de l'utilisateur actuel (point d'accès protégé)
@app.get("/users/me", response_model=UserRead)
async def read_users_me(current_user: UserModel = Depends(current_active_user)):
return current_user
# Obtention de tous les posts (point d'accès protégé)
@app.get("/feed", response_model=List[PostWithUser])
async def get_feed(
session: AsyncSession = Depends(get_async_session),
current_user: UserModel = Depends(current_active_user) # Authentification requise
):
# Requête des posts avec informations sur l'utilisateur
stmt = select(PostModel).order_by(PostModel.created_at.desc())
result = await session.execute(stmt)
posts = result.scalars().all()
# Construction de la réponse avec les informations de l'utilisateur et le statut de propriétaire
posts_data = []
for post in posts:
is_owner = (post.user_id == current_user.id)
posts_data.append(PostWithUser(
id=post.id,
title=post.title,
content=post.content,
created_at=post.created_at,
user_id=post.user_id,
file_url=post.file_url,
file_type=post.file_type,
file_name=post.file_name,
is_owner=is_owner,
user_email=post.user.email if post.user else "Inconnu"
))
return posts_data
# Téléchargement d'un fichier (photo/vidéo) et création d'un post (point d'accès protégé)
@app.post("/upload", response_model=PostWithUser)
async def upload_file(
file: UploadFile = File(...),
caption: str = Form(...),
session: AsyncSession = Depends(get_async_session),
current_user: UserModel = Depends(current_active_user) # Authentification requise
):
# Génération d'un nom de fichier unique
file_extension = os.path.splitext(file.filename)[1]
unique_filename = f"{uuid.uuid4()}{file_extension}"
# Téléchargement du fichier dans ImageKit
try:
upload_result = imagekit.upload_file(
file=file.file,
file_name=unique_filename,
options=UploadFileRequestOptions(
use_unique_file_name=True,
tags=["backend_upload"],
folder="uploads" # Optionnel : dossier dans ImageKit
)
)
file_url = upload_result.url
file_type = "video" if file.content_type.startswith("video/") else "image"
file_name = upload_result.name
# Création d'un nouveau post dans la base de données
new_post = PostModel(
title=caption, # Utilise la légende comme titre
content=caption, # Ou on peut ajouter un champ séparé pour le contenu
user_id=current_user.id,
file_url=file_url,
file_type=file_type,
file_name=file_name
)
session.add(new_post)
await session.commit()
await session.refresh(new_post)
# Retourne les données du post, y compris l'URL et les informations de l'utilisateur
return PostWithUser(
id=new_post.id,
title=new_post.title,
content=new_post.content,
created_at=new_post.created_at,
user_id=new_post.user_id,
file_url=new_post.file_url,
file_type=new_post.file_type,
file_name=new_post.file_name,
is_owner=True, # Le nouveau post appartient toujours à l'utilisateur actuel
user_email=current_user.email
)
except Exception as e:
raise HTTPException(status_code=500, detail=f"Échec du téléchargement du fichier : {e}")
# Suppression d'un post (point d'accès protégé)
@app.delete("/posts/{post_id}", response_model=dict)
async def delete_post(
post_id: int,
session: AsyncSession = Depends(get_async_session),
current_user: UserModel = Depends(current_active_user) # Authentification requise
):
# Récupère le post de la base de données
stmt = select(PostModel).where(PostModel.id == post_id)
result = await session.execute(stmt)
post = result.scalars().first()
if not post:
raise HTTPException(status_code=404, detail="Post introuvable")
# Vérification des droits d'accès : seul l'auteur du post peut le supprimer
if post.user_id != current_user.id:
raise HTTPException(status_code=403, detail="Vous n'avez pas la permission de supprimer ce post")
# Suppression du post de la base de données
await session.delete(post)
await session.commit()
return {"message": "Post supprimé avec succès"}
# --- Schémas supplémentaires pour les utilisateurs ---
# Ces schémas héritent des schémas standards de FastAPI-Users,
# mais peuvent être étendus si nécessaire.
from fastapi_users import schemas
class UserRead(schemas.BaseUser[uuid.UUID]):
email: str
is_active: bool = True
is_superuser: bool = False
is_verified: bool = False
id: uuid.UUID # Assurez-vous que l'ID correspond au type dans le modèle de base de données
class UserCreate(schemas.BaseUserCreate):
password: str
email: str
is_active: bool = True
is_superuser: bool = False
is_verified: bool = False
class UserUpdate(schemas.BaseUserUpdate):
password: Optional[str] = None
email: Optional[str] = None
is_active: Optional[bool] = None
is_superuser: Optional[bool] = None
is_verified: Optional[bool] = None
# Mise à jour du modèle Post pour inclure les informations de l'utilisateur et le statut de propriétaire
class PostWithUser(Post):
user_id: Optional[int] # Ou UUID
file_url: str
file_type: str
file_name: str
is_owner: bool
user_email: str
# Mise à jour du point d'accès get_feed pour retourner PostWithUser
@app.get("/feed", response_model=List[PostWithUser])
async def get_feed(
session: AsyncSession = Depends(get_async_session),
current_user: UserModel = Depends(current_active_user)
):
stmt = select(PostModel).order_by(PostModel.created_at.desc())
result = await session.execute(stmt)
posts = result.scalars().all()
posts_data = []
for post in posts:
is_owner = (post.user_id == current_user.id)
posts_data.append(PostWithUser(
id=post.id,
title=post.title,
content=post.content,
created_at=post.created_at,
user_id=post.user_id,
file_url=post.file_url,
file_type=post.file_type,
file_name=post.file_name,
is_owner=is_owner,
user_email=post.user.email if post.user else "Inconnu"
))
return posts_data
# Mise à jour du point d'accès upload_file pour retourner PostWithUser
@app.post("/upload", response_model=PostWithUser)
async def upload_file(
file: UploadFile = File(...),
caption: str = Form(...),
session: AsyncSession = Depends(get_async_session),
current_user: UserModel = Depends(current_active_user)
):
file_extension = os.path.splitext(file.filename)[1]
unique_filename = f"{uuid.uuid4()}{file_extension}"
try:
upload_result = imagekit.upload_file(
file=file.file,
file_name=unique_filename,
options=UploadFileRequestOptions(
use_unique_file_name=True,
tags=["backend_upload"],
folder="uploads"
)
)
file_url = upload_result.url
file_type = "video" if file.content_type.startswith("video/") else "image"
file_name = upload_result.name
new_post = PostModel(
title=caption,
content=caption,
user_id=current_user.id,
file_url=file_url,
file_type=file_type,
file_name=file_name
)
session.add(new_post)
await session.commit()
await session.refresh(new_post)
return PostWithUser(
id=new_post.id,
title=new_post.title,
content=new_post.content,
created_at=new_post.created_at,
user_id=new_post.user_id,
file_url=new_post.file_url,
file_type=new_post.file_type,
file_name=new_post.file_name,
is_owner=True, # Le nouveau post appartient toujours à l'utilisateur actuel
user_email=current_user.email
)
except Exception as e:
raise HTTPException(status_code=500, detail=f"Échec du téléchargement du fichier : {e}")
# Mise à jour du modèle Post pour inclure ForeignKey et relationship
# Dans app/db.py :
# Ajouter dans la classe Post :
# user_id = Column(Integer, ForeignKey("users.id"))
# user = relationship("User", back_populates="posts")
# Ajouter dans la classe User :
# posts = relationship("Post", back_populates="user")
# S'assurer que User et Post héritent de Base et ont les champs correspondants.
# Il faut également mettre à jour les schémas Pydantic (PostCreate, Post, UserRead, UserCreate, UserUpdate)
# et s'assurer qu'ils correspondent aux modèles SQLAlchemy.
Téléchargement de fichiers avec ImageKit
L'intégration avec ImageKit permet de gérer facilement les fichiers multimédias.
-
Initialisation d'ImageKit : Dans
app/app.py, importez et initialisez le client ImageKit en utilisant les clés de.env. -
Traitement du téléchargement : Le point d'accès
/uploadaccepteUploadFileetcaptiondepuis un formulaire. Le fichier est téléchargé vers ImageKit, et l'URL obtenue est enregistrée dans la base de données avec les informations du post et de l'utilisateur.# Dans app/app.py from fastapi import File, UploadFile, Form # ... (autres imports) @app.post("/upload", response_model=PostWithUser) async def upload_file( file: UploadFile = File(...), caption: str = Form(...), session: AsyncSession = Depends(get_async_session), current_user: UserModel = Depends(current_active_user) ): # ... (logique de téléchargement vers ImageKit et sauvegarde en BD) pass
Transformations de fichiers multimédias
ImageKit permet d'appliquer des transformations aux images et vidéos directement via l'URL. Par exemple, redimensionnement, ajout de texte, application d'effets.
Exemple d'URL avec transformations :
https://ik.imagekit.io/votre_clé_publique/votre_nom_de_fichier.jpg?tr=w-300,h-200,fo-auto
Authentification et Autorisation (FastAPI-Users)
FastAPI-Users simplifie la mise en œuvre de l'authentification des utilisateurs à l'aide de JWT (JSON Web Tokens).
Concept JWT
JWT est une norme pour la transmission sécurisée d'informations entre parties sous forme d'objet JSON. Il se compose de trois parties : un en-tête, une charge utile et une signature. Le jeton est signé avec une clé secrète du serveur, ce qui permet de vérifier son authenticité.
Configuration de FastAPI-Users
- Modèles d'utilisateurs : Définissez le modèle
Userdansapp/db.py, qui hérite deSQLAlchemyUserTableet inclut les champs nécessaires (email, mot de passe, rôles). - Schémas d'utilisateurs : Créez les schémas
UserRead,UserCreate,UserUpdatedansapp/schemas.py. - Gestionnaire d'utilisateurs et backend d'authentification : Configurez
UserManager,BearerTransport,JWTStrategyetAuthenticationBackenddansapp/app.py. - Inclusion des routes : Utilisez
app.include_router()pour ajouter les routes d'authentification standard (inscription, connexion, réinitialisation de mot de passe).
Protection des points d'accès
Pour protéger les points d'accès, ajoutez la dépendance Depends(current_active_user) aux fonctions de point d'accès. Si l'utilisateur n'est pas authentifié, la requête sera rejetée.
# app/app.py
from fastapi_users import FastAPIUsers, BaseUserManager, UUID_ID
from fastapi_users.authentication import (
AuthenticationBackend,
BearerTransport,
JWTStrategy,
)
from fastapi_users.db import SQLAlchemyUserDatabase
# ... (définition des modèles et schémas)
# Obtention de l'utilisateur actif actuel
current_active_user = fastapi_users.current_user(active=True)
@app.get("/protected-route")
async def protected_route(current_user: UserModel = Depends(current_active_user)):
return {"message": f"Bonjour, {current_user.email} !"}
Autorisation (Vérification des droits d'accès)
Lors de la suppression d'un post, il faut s'assurer que l'utilisateur actuel est l'auteur du post.
# app/app.py
@app.delete("/posts/{post_id}", response_model=dict)
async def delete_post(
post_id: int,
session: AsyncSession = Depends(get_async_session),
current_user: UserModel = Depends(current_active_user)
):
# ... (récupération du post)
if post.user_id != current_user.id:
raise HTTPException(status_code=403, detail="Vous n'avez pas la permission de supprimer ce post")
# ... (suppression du post)
Frontend (Streamlit)
Pour démontrer le fonctionnement de l'API, un frontend simple peut être créé à l'aide de la bibliothèque Streamlit. Streamlit permet de créer rapidement des applications web interactives en Python.
-
Installation de Streamlit :
uv add streamlit -
Création du fichier frontend : Créez un fichier
frontend.pyavec du code qui interagit avec l'API (envoie des requêtes d'authentification, de téléchargement de fichiers, de récupération du flux). Le code frontend inclut généralement :- Gestion de l'état de la session (stockage du jeton JWT).
- Fonctions pour envoyer des requêtes HTTP avec le jeton dans l'en-tête.
- Interfaces pour l'inscription, la connexion, le téléchargement de fichiers, l'affichage du flux.
-
Lancement de Streamlit :
uv run streamlit run frontend.py
Conclusion
L'application développée démontre une approche complète pour la création d'une API web moderne à l'aide de FastAPI. Elle inclut le traitement des requêtes, l'interaction avec la base de données, une authentification sécurisée des utilisateurs et l'intégration avec des services externes pour le traitement des fichiers multimédias. L'API obtenue constitue la base pour la création d'applications web évolutives et fiables.
Aperçu de la vidéo
Aperçu de la vidéo et démonstration du projet finalisé.
- Démonstration d'une application de photos/vidéos.
- Possibilité de se connecter, de voir le flux, de télécharger du contenu.
- Utilisation de Streamlit pour le frontend.
Architecture et Théorie des Applications Web
Explication de l'architecture de l'application web et des concepts théoriques clés.
- Concepts d'URL, de domaine, de chemin (endpoint).
- Rôle des paramètres de requête (query parameters).
- Structure de la requête (request) et de la réponse (response).
- Méthodes HTTP : GET, POST, PUT, DELETE.
- Codes de statut HTTP (200, 404, etc.).
Configuration du Projet et Installation
Configuration de l'environnement de développement et installation des dépendances nécessaires.
- Utilisation de
uvpour la gestion des dépendances. - Installation de
fastapi,python-dotenv,fastapi-users,sqlalchemy,imagekitio,uvicorn. - Création d'un fichier
.envpour stocker les clés.
Configuration de FastAPI et Bases
Création de base d'une application FastAPI et configuration du premier endpoint.
- Création d'une instance
FastAPI. - Définition de l'endpoint
/hello-worldavec la méthode GET. - Retour d'une réponse JSON.
- Lancement du serveur avec
uvicorn. - Utilisation de
/docspour la documentation automatique.
GET et Récupération des Posts
Travail avec les endpoints pour récupérer des données, y compris les paramètres de chemin et de requête.
- Création de l'endpoint
/postspour récupérer tous les posts. - Utilisation des paramètres de chemin (par exemple,
/post/{id}) pour récupérer un post spécifique. - Gestion des erreurs (HTTPException 404).
- Utilisation des paramètres de requête (par exemple,
limit) pour le filtrage.
Corps de Requête et POST
Mise en œuvre d'un endpoint POST pour créer de nouvelles entrées à l'aide de modèles Pydantic.
- Définition du schéma de données avec Pydantic (
PostCreate). - Réception des données via le corps de la requête (request body).
- Validation automatique des données par FastAPI.
- Création d'un nouveau post et retour de celui-ci.
Connexion à la Base de Données
Connexion à une base de données SQLite et définition des modèles de données.
- Utilisation de SQLAlchemy pour l'ORM.
- Configuration du moteur asynchrone
create_async_engine. - Définition du modèle
Postavec les champsid,caption,url,file_type,file_name,created_at. - Configuration du cycle de vie de l'application (
lifespan) pour créer les tables.
Téléchargement d'Images et Vidéos (ImageKit)
Mise en œuvre du téléchargement de fichiers (images et vidéos) à l'aide d'ImageKit.
- Intégration avec ImageKit pour le stockage et le traitement des médias.
- Création de fichiers temporaires pour le téléchargement.
- Utilisation de
upload_filedeimagekitio. - Stockage de l'URL du fichier et des métadonnées dans la base de données.
- Gestion des erreurs de téléchargement.
Suppression des Posts
Mise en œuvre de la fonctionnalité de suppression d'entrées de la base de données.
- Création de l'endpoint DELETE
/post/{post_id}. - Récupération de l'ID du post à partir du paramètre de chemin.
- Recherche du post dans la base de données.
- Suppression du post et confirmation de l'opération.
Authentification des Utilisateurs et Jetons JWT
Configuration de l'authentification des utilisateurs à l'aide de JWT et FastAPI Users.
- Utilisation de
fastapi-userspour la gestion des utilisateurs. - Configuration de la stratégie JWT et du backend d'authentification.
- Définition des modèles
Useret des relations avecPost. - Création d'endpoints pour l'enregistrement, la connexion, la déconnexion.
Protection des Endpoints
Protection des endpoints de l'API pour que seuls les utilisateurs authentifiés y aient accès.
- Utilisation de
Depends(current_active_user)pour protéger les endpoints. - Vérification des droits d'accès lors de la suppression d'un post.
- Affichage des informations utilisateur dans le flux.
- Utilisation de Streamlit pour le frontend.
Frontend Streamlit
Création d'une interface utilisateur simple avec Streamlit pour interagir avec l'API.
- Utilisation de Streamlit pour créer l'interface utilisateur.
- Gestion du jeton JWT dans la session.
- Mise en œuvre de la logique de connexion, d'enregistrement, de téléchargement de fichiers et d'affichage du flux.
- Utilisation d'ImageKit pour afficher les images avec des transformations.
