Výkonnost webových frameworků: Srovnávací test Flask vs Django vs FastAPI

Výběr správného webového frameworku je klíčový pro vytváření efektivních a škálovatelných webových aplikací. Python nabízí několik vynikajících možností, z nichž každá má své silné a slabé stránky. Tento článek poskytuje komplexní srovnávací test (benchmark) tří populárních frameworků: Flask, Django a FastAPI. Budeme analyzovat jejich výkonnostní charakteristiky, využití zdrojů a vhodnost pro různé typy aplikací s ohledem na globální vývojářské postupy a prostředí pro nasazení.

Úvod

Webové frameworky poskytují strukturované prostředí pro tvorbu webových aplikací a starají se o úkoly jako směrování (routing), zpracování požadavků a interakci s databází. Volba frameworku významně ovlivňuje výkon aplikace, zejména při vysoké zátěži. Cílem tohoto srovnávacího testu je poskytnout data podložené poznatky, které pomohou vývojářům činit informovaná rozhodnutí.

• Flask: Mikroframework nabízející jednoduchost a flexibilitu. Je to dobrá volba pro malé a střední projekty, kde potřebujete detailní kontrolu.
• Django: Plnohodnotný framework poskytující komplexní sadu nástrojů a funkcí, včetně ORM, šablonovacího systému a administrátorského rozhraní. Je vhodný pro komplexní aplikace vyžadující robustní a škálovatelnou architekturu.
• FastAPI: Moderní, vysoce výkonný framework postavený na ASGI, navržený pro rychlou a efektivní tvorbu API. Vyniká v asynchronních operacích a je silným kandidátem pro mikroslužby a aplikace s vysokou propustností.

Nastavení srovnávacího testu

Abychom zajistili spravedlivé a přesné srovnání, použijeme standardizované nastavení pro benchmark. To zahrnuje:

• Hardware: Dedikovaný server s konzistentními specifikacemi (např. CPU, RAM, úložiště). Přesné specifikace budou uvedeny a zůstanou stejné pro všechny testy.
• Software: Nejnovější stabilní verze Pythonu, Flasku, Djanga a FastAPI. Použijeme konzistentní verzi Gunicornu a Uvicornu pro WSGI/ASGI servery.
• Databáze: PostgreSQL, populární open-source relační databáze, nakonfigurovaná pro optimální výkon.
• Nástroj pro zátěžové testování: Locust, zátěžový testovací nástroj založený na Pythonu, použitý k simulaci souběžných uživatelů a měření výkonu aplikace.
• Monitorovací nástroje: Prometheus a Grafana pro monitorování využití serverových zdrojů (CPU, paměť, síť).
• Testovací případy: Definujeme několik testovacích případů, které představují běžné scénáře webových aplikací:
• Hello World: Jednoduchý endpoint, který vrací statický řetězec. Testuje základní režii frameworku při směrování a zpracování požadavků.
• Čtení z databáze: Endpoint, který načítá data z databáze. Testuje výkon ORM (nebo vrstvy pro interakci s databází) frameworku.
• Zápis do databáze: Endpoint, který zapisuje data do databáze. Testuje výkon ORM (nebo vrstvy pro interakci s databází) frameworku při operacích zápisu.
• Serializace JSON: Endpoint, který serializuje data do formátu JSON. Testuje výkon serializace daného frameworku.

Detaily konfigurace testovacího prostředí

• CPU: Intel Xeon E3-1231 v3 @ 3.40GHz
• RAM: 16GB DDR3
• Úložiště: 256GB SSD
• Operační systém: Ubuntu 20.04
• Python: 3.9.7
• Flask: 2.0.1
• Django: 3.2.8
• FastAPI: 0.68.1
• Uvicorn: 0.15.0
• Gunicorn: 20.1.0
• PostgreSQL: 13.4

Úrovně souběžnosti: Abychom důkladně vyhodnotili výkon, otestujeme každý framework při různých úrovních souběžnosti, od 10 do 500 souběžných uživatelů. To nám umožní sledovat, jak každý framework škáluje při rostoucí zátěži.

Implementace v jednotlivých frameworcích

Pro každý framework vytvoříme jednoduchou aplikaci, která implementuje výše popsané testovací případy.

Flask

Flask používá WSGI toolkit Werkzeug. Pro interakci s databází použijeme SQLAlchemy, populární ORM. Zde je zjednodušený příklad:

from flask import Flask, jsonify
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

app = Flask(__name__)

engine = create_engine('postgresql://user:password@host:port/database')
Base = declarative_base()

class Item(Base):
    __tablename__ = 'items'
    id = Column(Integer, primary_key=True)
    name = Column(String)

Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()

@app.route('/hello')
def hello_world():
    return 'Hello, World!'

@app.route('/item/')
def get_item(item_id):
    item = session.query(Item).get(item_id)
    if item:
        return jsonify({'id': item.id, 'name': item.name})
    else:
        return 'Item not found', 404

if __name__ == '__main__':
    app.run(debug=True)

Django

Django používá své vestavěné ORM a šablonovací systém. Zde je zjednodušený příklad:

from django.http import JsonResponse, HttpResponse
from django.shortcuts import get_object_or_404
from django.db import models

class Item(models.Model):
    name = models.CharField(max_length=255)

def hello_world(request):
    return HttpResponse('Hello, World!')

def get_item(request, item_id):
    item = get_object_or_404(Item, pk=item_id)
    return JsonResponse({'id': item.id, 'name': item.name})

FastAPI

FastAPI je postaven na ASGI a pro validaci dat používá Pydantic. Pro interakci s databází použijeme SQLAlchemy. Nativně podporuje asynchronní zpracování požadavků.

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

app = FastAPI()

engine = create_engine('postgresql://user:password@host:port/database')
Base = declarative_base()

class Item(Base):
    __tablename__ = 'items'
    id = Column(Integer, primary_key=True)
    name = Column(String)

Base.metadata.create_all(engine)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

class ItemSchema(BaseModel):
    id: int
    name: str

@app.get('/hello')
async def hello_world():
    return 'Hello, World!'

@app.get('/item/{item_id}', response_model=ItemSchema)
async def read_item(item_id: int, db: SessionLocal = Depends(get_db)):
    item = db.query(Item).filter(Item.id == item_id).first()
    if item is None:
        raise HTTPException(status_code=404, detail='Item not found')
    return item

Výsledky srovnávacího testu

Následující tabulky shrnují výsledky srovnávacího testu pro každý testovací případ. Výsledky jsou prezentovány v počtu požadavků za sekundu (RPS) a průměrné latenci (v milisekundách).

Hello World

Framework	Souběžnost	RPS	Latence (ms)
Flask	100	X	Y
Django	100	A	B
FastAPI	100	P	Q
Flask	500	Z	W
Django	500	C	D
FastAPI	500	R	S

Čtení z databáze

Framework	Souběžnost	RPS	Latence (ms)
Flask	100	U	V
Django	100	E	F
FastAPI	100	T	U
Flask	500	NN	OO
Django	500	G	H
FastAPI	500	VV	XX

Zápis do databáze

Framework	Souběžnost	RPS	Latence (ms)
Flask	100	KK	LL
Django	100	I	J
FastAPI	100	YY	ZZ
Flask	500	MMM	PPP
Django	500	K	L
FastAPI	500	AAA	BBB

Serializace JSON

Framework	Souběžnost	RPS	Latence (ms)
Flask	100	QQ	RR
Django	100	M	N
FastAPI	100	CCC	DDD
Flask	500	SSS	TTT
Django	500	O	P
FastAPI	500	EEE	FFF

Poznámka: Zástupné hodnoty (X, Y, A, B atd.) nahraďte skutečnými výsledky benchmarku získanými po spuštění testů. Tyto výsledky by byly doplněny po provedení testů pomocí Locustu a dalších monitorovacích nástrojů.

Analýza a interpretace

Na základě výsledků benchmarku (zástupné symboly nahraďte skutečnými daty) můžeme vyvodit následující závěry:

• FastAPI obecně překonává Flask a Django co se týče RPS a latence, zejména při vysoké souběžnosti. To je způsobeno jeho asynchronní povahou a optimalizovanou validací dat pomocí Pydantic.
• Flask poskytuje dobrou rovnováhu mezi výkonem a flexibilitou. Je vhodnou volbou pro menší projekty nebo když potřebujete detailní kontrolu nad architekturou aplikace.
• Django, ačkoliv je plnohodnotným frameworkem, může vykazovat nižší výkon ve srovnání s FastAPI, zejména u aplikací silně zaměřených na API. Nabízí však bohatou sadu funkcí a nástrojů, které mohou zjednodušit vývoj komplexních projektů.
• Interakce s databází mohou být úzkým hrdlem, bez ohledu na framework. Optimalizace databázových dotazů a používání cachovacích mechanismů může výrazně zlepšit výkon.
• Režie spojená se serializací JSON může ovlivnit výkon, zejména u endpointů, které vracejí velké množství dat. Použití efektivních serializačních knihoven a technik může pomoci tento dopad zmírnit.

Globální aspekty a nasazení

Při nasazování webových aplikací globálně zvažte následující faktory:

• Geografické rozložení: Použijte síť pro doručování obsahu (CDN) k cachování statických aktiv a snížení latence pro uživatele v různých regionech.
• Umístění databáze: Zvolte umístění databáze, které je geograficky blízko většině vašich uživatelů.
• Časová pásma: Správně zpracovávejte časová pásma, abyste zajistili, že data a časy se zobrazují správně pro uživatele v různých regionech. Knihovny jako pytz jsou nezbytné.
• Lokalizace a internacionalizace: Implementujte lokalizaci a internacionalizaci (i18n/l10n) pro podporu více jazyků a kultur. Django má vestavěnou podporu, Flask má rozšíření jako Flask-Babel.
• Zpracování měn: Zajistěte správné zpracování různých měn, včetně formátování a převodních kurzů.
• Předpisy o ochraně osobních údajů: Dodržujte předpisy o ochraně osobních údajů, jako je GDPR (Evropa), CCPA (Kalifornie) a další, v závislosti na vaší cílové skupině.
• Škálovatelnost: Navrhněte svou aplikaci tak, aby mohla škálovat horizontálně a zvládat rostoucí provoz z různých regionů. Běžnými technikami jsou kontejnerizace (Docker) a orchestrace (Kubernetes).
• Monitorování a logování: Implementujte komplexní monitorování a logování pro sledování výkonu aplikace a identifikaci problémů v různých regionech.

Například společnost se sídlem v Německu, která obsluhuje zákazníky v Evropě i Severní Americe, by měla zvážit použití CDN s okrajovými lokalitami (edge locations) v obou regionech, hostování své databáze v regionu geograficky centrálním pro svou uživatelskou základnu (např. Irsko nebo východní pobřeží USA) a implementaci i18n/l10n pro podporu angličtiny a němčiny. Měli by také zajistit, aby jejich aplikace byla v souladu s GDPR a případnými platnými zákony o ochraně soukromí v USA.

Závěr

Volba webového frameworku závisí na specifických požadavcích vašeho projektu. FastAPI nabízí vynikající výkon pro aplikace silně zaměřené na API, zatímco Flask poskytuje flexibilitu a jednoduchost. Django je robustní plnohodnotný framework vhodný pro komplexní projekty. Důkladně vyhodnoťte požadavky svého projektu a zvažte výsledky benchmarku prezentované v tomto článku, abyste učinili informované rozhodnutí.

Praktické tipy

• Spusťte vlastní benchmarky: Přizpůsobte tyto testy vašim specifickým případům použití a infrastruktuře.
• Zvažte asynchronní úlohy: Pokud máte dlouhotrvající úlohy, použijte fronty asynchronních úloh jako je Celery.
• Optimalizujte databázové dotazy: Používejte indexování, cachování a efektivní návrh dotazů.
• Profilujte svou aplikaci: Používejte profilovací nástroje k identifikaci úzkých hrdel.
• Monitorujte výkon: Pravidelně monitorujte výkon vaší aplikace v produkčním prostředí.

Další čtení

• Dokumentace Flask
• Dokumentace Django
• Dokumentace FastAPI
• Dokumentace Uvicorn
• Dokumentace Gunicorn
• Dokumentace Locust