Mémo Python Web

1. Architecture & Cycle de Vie

Dans une application Flask, le flux suit une route précise de la requête à la réponse :

2. Les Contextes (La "Magie" de Flask)

Flask utilise des Proxies pour accéder à des données globales sans polluer les signatures de fonctions :

• request : Accès aux données de la requête (args, form, json).
• session : Stockage sécurisé côté client (cookies signés).
• g : Objet temporaire pour une seule requête (ex: stocker la connexion DB).
• current_app : Accès à l'instance de l'application active.

1. Le Concept de "Session"

La Session agit comme une Unité de Travail (Unit of Work). Elle suit tous les changements apportés à vos objets avant de les synchroniser avec la base.

2. Définition d'un Modèle Pro

Un modèle bien défini utilise des types précis et des contraintes pour garantir l'intégrité des données.

from flask_sqlalchemy import SQLAlchemy
from datetime import datetime

db = SQLAlchemy()

class Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100), nullable=False)
    content = db.Column(db.Text, nullable=False)
    date = db.Column(db.DateTime, default=datetime.utcnow)
    
    # Relation Many-to-One
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'))

1. Le Pattern MVT

Django utilise une variante du MVC appelée Model-View-Template. La logique de contrôle est gérée par le framework lui-même.

2. L'Interface d'Administration

C'est l'un des "tueurs" de Django : une interface de gestion de contenu générée automatiquement à partir de vos modèles.

from django.contrib import admin
from .models import Product

@admin.register(Product)
class ProductAdmin(admin.ModelAdmin):
    list_display = ('name', 'price', 'stock')
    search_fields = ('name',)
    list_filter = ('category',)

1. ASGI vs WSGI : L'Asynchronisme

Contrairement à Flask (WSGI), FastAPI est ASGI (Asynchronous Server Gateway Interface). Il peut gérer des milliers de connexions simultanément sans bloquer le serveur.

2. Validation & Pydantic

Fini les erreurs de type KeyError. FastAPI convertit le JSON entrant en vrais objets Python typés.

from pydantic import BaseModel, Field

class Item(BaseModel):
    name: str
    price: float = Field(gt=0, description="Doit être positif")
    is_offer: bool | None = None

@app.post("/items/")
async def create_item(item: Item):
    return item  # Auto-sérialisation JSON

1. Les 6 Contraintes REST

• 👤 Client-Serveur : Séparation des préoccupations (UI vs Data).
• ☁️ Stateless : Chaque requête doit contenir toute l'info nécessaire.
• 💾 Cacheable : Les réponses doivent indiquer si elles sont réutilisables.
• 🧱 Layered System : Le client ne sait pas s'il parle au serveur final.
• 🌐 Interface Uniforme : Utilisation cohérente des URI et méthodes.
• 📜 Code on Demand (Optionnel) : Envoi de scripts exécutables.

2. Cycle Requête / Réponse

1. Hashing : La Règle du "Slow"

On ne stocke JAMAIS de mot de passe. On stocke un Hash unique. Plus l'algorithme est "lent" (coûteux en CPU/Mémoire), plus il résiste aux attaques par force brute.

from passlib.context import CryptContext

pwd_context = CryptContext(schemes=["argon2", "bcrypt"])

# Inscription
hash = pwd_context.hash("mypassword")

# Vérification
is_ok = pwd_context.verify("mypassword", hash)

2. JWT : Authentification Sans État

Le JSON Web Token permet d'identifier un utilisateur sans interroger la DB à chaque requête. Le secret côté serveur garantit l'intégrité.

1. L'Event Loop & asyncio

Au lieu de créer un thread par utilisateur (coûteux), Python utilise une Boucle d'Événements. Quand une tâche attend (ex: lecture DB), le serveur passe instantanément à la suivante.

2. WebSockets vs HTTP

Alors que l'HTTP ferme la connexion après chaque réponse, le WebSocket maintient un tunnel ouvert et bidirectionnel.

1. Architecture Distribuée

L'application (Producteur) envoie un message dans une file d'attente (Broker). Un processus séparé (Worker) récupère ce message et l'exécute en arrière-plan.

2. Stratégies de Délégation

1. La Pyramide des Tests

Pour une stratégie efficace, privilégiez une large base de tests unitaires (rapides) et moins de tests de bout-en-bout (lents/fragiles).

2. La Puissance de Pytest

Fini la lourdeur de unittest. Pytest utilise de simples assert et un système de Fixtures révolutionnaire.

import pytest
from main import app
from fastapi.testclient import TestClient

@pytest.fixture
def client():
    # Setup : crée l'objet avant le test
    with TestClient(app) as c:
        yield c
    # Teardown : nettoyage auto après

1. L'Architecture Standard

En production, on ne branche jamais l'application directement sur Internet. On utilise Nginx comme "bouclier" et Gunicorn/Uvicorn comme moteur de calcul.

2. Pourquoi Nginx ?

• ⚡ Fichiers Statiques : Nginx sert les images/CSS/JS bien plus vite que Python.
• 🔒 SSL / TLS : C'est là qu'on gère les certificats (Certbot/LetsEncrypt).
• 🧼 Buffering : Protège Python des clients lents qui "bloquent" les connexions.

1. Anatomie d'un Dockerfile Pro

L'ordre des instructions est crucial pour profiter du cache des couches. Copiez toujours les fichiers de dépendances avant le code.

# 1. Image de base légère
FROM python:3.11-slim

# 2. Variables d'environnement Python
ENV PYTHONDONTWRITEBYTECODE=1
ENV PYTHONUNBUFFERED=1

WORKDIR /app

# 3. Cache des dépendances
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 4. Copie du code
COPY . .

CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:8000", "app:app"]

2. Cycle de Vie & Couches