~4m2:05:44
Tech With Tim

Learn Fast API With This ONE Project

30 oct. 2025

Read: ~4m · You save: 122 min

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).

  1. Initialisation du projet :

    uv init .
    

    Cette commande crée le fichier pyproject.toml pour la gestion des dépendances du projet.

  2. Installation des dépendances :

    uv add fastapi uvicorn python-dotenv sqlalchemy fastapi-users imagekit-io aiosqlite
    
    • fastapi : 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.
  3. 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_url
    

    Il 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 chemin item_id. FastAPI convertit automatiquement item_id en int et effectue la validation.
  • q: str | None = None : Définit un paramètre de requête optionnel q de type str.

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.

  1. Initialisation d'ImageKit : Dans app/app.py, importez et initialisez le client ImageKit en utilisant les clés de .env.

  2. Traitement du téléchargement : Le point d'accès /upload accepte UploadFile et caption depuis 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

  1. Modèles d'utilisateurs : Définissez le modèle User dans app/db.py, qui hérite de SQLAlchemyUserTable et inclut les champs nécessaires (email, mot de passe, rôles).
  2. Schémas d'utilisateurs : Créez les schémas UserRead, UserCreate, UserUpdate dans app/schemas.py.
  3. Gestionnaire d'utilisateurs et backend d'authentification : Configurez UserManager, BearerTransport, JWTStrategy et AuthenticationBackend dans app/app.py.
  4. 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.

  1. Installation de Streamlit :

    uv add streamlit
    
  2. Création du fichier frontend : Créez un fichier frontend.py avec 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.
  3. 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 uv pour la gestion des dépendances.
  • Installation de fastapi, python-dotenv, fastapi-users, sqlalchemy, imagekitio, uvicorn.
  • Création d'un fichier .env pour 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-world avec la méthode GET.
  • Retour d'une réponse JSON.
  • Lancement du serveur avec uvicorn.
  • Utilisation de /docs pour 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 /posts pour 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 Post avec les champs id, 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_file de imagekitio.
  • 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-users pour la gestion des utilisateurs.
  • Configuration de la stratégie JWT et du backend d'authentification.
  • Définition des modèles User et des relations avec Post.
  • 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.