Moteur web Python pour un site en prod (sans asynchrone) ?

Bonjour,

Merci pour ta réponse, même si je pense qu’on ne s’est pas totalement compris sur mes contraintes.

1. Sur les "objectifs techniques" :

Ce ne sont pas des choix arbitraires. Si j'exclus l'asynchrone, ce n'est pas par goût personnel ou par ignorance, c’est parce que :

• Je travaille avec des modules synchrones, certains natifs, d'autres plus bas niveau, qui ne sont pas compatibles avec l’async/await. Les forcer à fonctionner dans un contexte asynchrone, c’est prendre des risques de blocage, de fuites mémoire, ou de comportements imprévisibles.

• En pratique, j’ai déjà testé FastAPI, et j’ai été confronté à ces problèmes : complexité inutile, erreurs silencieuses, mauvaise compatibilité avec certaines bibliothèques.

2. Sur la gestion de l’upload :

Je suis bien conscient qu’on peut gérer les uploads autrement.
Mais mon retour d’expérience avec Flask, par exemple, montre que le traitement du fichier ne commence qu’une fois l’intégralité reçue.
- Cela veut dire que je n’ai aucun contrôle sur les chunks ou les headers en amont, ce qui laisse une fenêtre exploitable pour un upload flood avant que mon app n’ait la main.
C’est exactement ce que j’essaie d’éviter. Je veux pouvoir intercepter les données dès les premiers octets si nécessaire.

3. Sur les protections :

Je ne compte évidemment pas uniquement sur l’application pour sécuriser le système :

• J’ai NGINX en reverse proxy, avec des limites de débit, de taille, etc...

• Des pare-feu en amont

• Et la couche applicative en dernière ligne

Mais je veux aussi avoir un contrôle bas niveau côté serveur applicatif, surtout pour les cas où les protections frontales ne suffisent pas (attaque bien formée, contournement, etc..). Je ne veux pas que l’app soit passive dans ce modèle.

4. Et enfin, sur les ressources, budget et compétences :

Justement, mon approche prend en compte :

• Le besoin d’un système ultra optimisé, stable, et sûr

• Avec des outils que je maîtrise à fond, en synchrones, et qui peuvent monter en charge via Gunicorn + multithreading

.

La taille des fichiers doit être dynamique, et non fixe comme Flask l’impose :

app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024

Alors qu’avec FastAPI, j’ai request.stream() qui contient le flux du fichier, ce qui me permet de le gérer dès le début, sans problème de buffering (comme l’a expliqué GPT).
J'ai le même problème de buffering avec Django également.

@app.post("/upload")
async def upload_stream(request: Request):
    total_size = 0

    async for chunk in request.stream():
        if not chunk:
            break
        start_time = time.time()

        total_size += len(chunk)

        print(f"Reçu {len(chunk)} octets, total = {total_size}")

        if total_size > MAX_UPLOAD_SIZE:
            raise HTTPException(status_code=413, detail="Upload exceeds max size")

        elapsed_time = time.time() - start_time
        expected_time = len(chunk) / ( 0.2 * 1024 * 1024 )         # 5Mo/s

        if elapsed_time < expected_time:
            await asyncio.sleep(expected_time - elapsed_time)


    return JSONResponse(content={"detail": "Upload processed", "total_size": total_size})

/\    

Ce code est utilisé par FastAPI pour gérer les uploads sans buffering. Mais comme je l’ai mentionné, je fais des commandes bloquantes comme :

query = {"uploadTime": {"$lte": last_uploaded}}
files_cursor = collection.find(query) \
                             .sort("uploadTime", -1) \
                             .skip((page - 1) * per_page) \
                             .limit(per_page)

Cela bloque le serveur pendant l’exécution de la commande, ce qui pose problème, car je gère un très grand nombre de demandes et je ne peux pas me permettre de tout bloquer. C’est là qu’intervient le multithreading : je dois faire du vrai parallélisme (comme avec Threading).
Le problème, c’est que FastAPI ne supporte pas cela, tandis que Flask, lui, place chaque demande dans un nouveau thread, mais il a l’inconvénient de ne pas permettre des uploads dynamiques.

| **Critères**                                          | **Django** | **Flask**   | **FastAPI**  |
|----------------------------------------------------|-----------------|----------------|--------------------|
| **MultiThread**                                   |je sais pas  |     ✅         |        ❌           |
| **Contrôle du Stream des Uploads**|        ❌       |      ❌         |        ✅           |