Fastapi Avancé : Api Rest Sécurisée Avec Jwt Et Postgresql

FastAPI est un framework Python moderne qui permet de créer des API REST performantes et sécurisées. Dans ce guide avancé, vous apprendrez à créer une API complète connectée à PostgreSQL, avec authentification JWT, CRUD complet et intégration avec un frontend React ou Flutter.

Chez Akamasoft, nous utilisons cette approche pour construire des API robustes, évolutives et prêtes pour la production.

1. Architecture de l’API

[ Frontend React / Flutter ]
           |
           v
       [ NGINX / Reverse Proxy ]
           |
        [ FastAPI ]
           |
[ PostgreSQL / Redis (cache)]

Cette architecture permet de gérer un grand volume de requêtes tout en assurant sécurité et performance.

2. Prérequis

• Python 3.9 ou plus
• PostgreSQL installé
• Environnement virtuel
• Éditeur de code (VS Code recommandé)
• Connaissances de base en Python

3. Installation des dépendances

pip install fastapi uvicorn psycopg2-binary sqlalchemy
pip install python-jose passlib[bcrypt] python-multipart

4. Configuration de la base de données PostgreSQL

DATABASE_URL = "postgresql://user:password@localhost:5432/akamasoftdb"

Création des tables avec SQLAlchemy :

from sqlalchemy import Column, Integer, String, Float
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class Produit(Base):
    __tablename__ = "produits"
    id = Column(Integer, primary_key=True, index=True)
    nom = Column(String, unique=True, index=True)
    description = Column(String)
    prix = Column(Float)

5. Authentification JWT sécurisée

from datetime import datetime, timedelta
from jose import JWTError, jwt
from passlib.context import CryptContext

SECRET_KEY = "VOTRE_SECRET_KEY"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30

pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

Création d’un token :

def create_access_token(data: dict, expires_delta: timedelta = None):
    to_encode = data.copy()
    expire = datetime.utcnow() + (expires_delta if expires_delta else timedelta(minutes=15))
    to_encode.update({"exp": expire})
    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
    return encoded_jwt

Cette méthode sécurise l’accès aux endpoints sensibles.

6. CRUD complet pour les produits

from fastapi import FastAPI, Depends, HTTPException
from sqlalchemy.orm import Session
from .database import SessionLocal, engine
from .models import Base, Produit
from .schemas import ProduitCreate, ProduitRead
from typing import List

app = FastAPI(title="API Akamasoft sécurisée")

Base.metadata.create_all(bind=engine)

# Dépendance pour obtenir la session DB
def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@app.post("/produits/", response_model=ProduitRead)
def creer_produit(produit: ProduitCreate, db: Session = Depends(get_db)):
    db_produit = Produit(nom=produit.nom, description=produit.description, prix=produit.prix)
    db.add(db_produit)
    db.commit()
    db.refresh(db_produit)
    return db_produit

@app.get("/produits/", response_model=List[ProduitRead])
def lire_produits(skip: int = 0, limit: int = 10, db: Session = Depends(get_db)):
    produits = db.query(Produit).offset(skip).limit(limit).all()
    return produits

7. Sécurisation des endpoints avec JWT

from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

def verifier_token(token: str = Depends(oauth2_scheme)):
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        return payload
    except JWTError:
        raise HTTPException(status_code=401, detail="Token invalide")

Ajoutez `Depends(verifier_token)` à toutes les routes sécurisées.

---

8. Connexion avec un frontend React ou mobile Flutter

Exemple JavaScript (React)

fetch("http://127.0.0.1:8000/produits/", {
  headers: { "Authorization": "Bearer VOTRE_JWT" }
})
.then(res => res.json())
.then(data => console.log(data));

Exemple Flutter

var response = await http.get(
  Uri.parse("http://127.0.0.1:8000/produits/"),
  headers: {"Authorization": "Bearer $jwtToken"},
);

---

9. Optimisation et scalabilité

• Utiliser l’asynchrone pour les opérations longues
• Mise en cache avec Redis
• Docker + Nginx pour le déploiement en production
• Load Balancer pour la montée en charge

[ Frontend React / Flutter ]
           |
       [ NGINX / Reverse Proxy ]
           |
        [ FastAPI ]
           |
[ PostgreSQL / Redis (cache)]

---

10. Bonnes pratiques de sécurité

• Activer HTTPS
• Valider toutes les entrées utilisateurs
• Limiter les permissions
• Mettre à jour régulièrement les dépendances
• Journaliser et monitorer les accès à l’API

---

Conclusion

Vous savez maintenant créer une API REST sécurisée et complète avec FastAPI et PostgreSQL, gérer un CRUD complet, sécuriser les endpoints avec JWT et connecter votre API à un frontend web ou mobile.

Chez Akamasoft, nous accompagnons les entreprises dans le développement d’API modernes, sécurisées et scalables, prêtes à répondre aux besoins du marché africain et international.

from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker

DATABASE_URL = "postgresql+asyncpg://user:pass@db:5432/dbname"

engine = create_async_engine(DATABASE_URL, echo=False)
AsyncSessionLocal = async_sessionmaker(engine, expire_on_commit=False, class_=AsyncSession)

# Dépendance injectée dans les routes
async def get_db():
    async with AsyncSessionLocal() as session:
        yield session

version: '3.8'
services:
  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - postgres_data:/var/lib/postgresql/data

  api:
    build: .
    command: sh -c "alembic upgrade head && uvicorn app.main:app --host 0.0.0.0 --port 8000 --workers 4"
    env_file:
      - .env
    depends_on:
      - db

volumes:
  postgres_data: