Tinklo karkasų našumas: Flask, Django ir FastAPI palyginamoji analizė

Tinkamo tinklo karkaso pasirinkimas yra labai svarbus kuriant efektyvias ir mastelį keičiančias žiniatinklio programas. Python siūlo keletą puikių variantų, kurių kiekvienas turi savo stipriąsias ir silpnąsias puses. Šiame straipsnyje pateikiama išsami trijų populiarių karkasų palyginamoji analizė: Flask, Django ir FastAPI. Analizuosime jų našumo charakteristikas, resursų naudojimą ir tinkamumą įvairių tipų programoms, atsižvelgdami į pasaulines kūrimo praktikas ir diegimo aplinkas.

Įvadas

Tinklo karkasai suteikia struktūrizuotą aplinką žiniatinklio programoms kurti, tvarkant tokias užduotis kaip maršruto parinkimas, užklausų apdorojimas ir sąveika su duomenų baze. Karkaso pasirinkimas daro didelę įtaką programos našumui, ypač esant didelei apkrovai. Šios palyginamosios analizės tikslas – pateikti duomenimis pagrįstas įžvalgas, kurios padėtų kūrėjams priimti pagrįstus sprendimus.

• Flask: Mikrokarkasas, siūlantis paprastumą ir lankstumą. Tai geras pasirinkimas mažiems ir vidutinio dydžio projektams, kur reikalinga smulkiagrūdė kontrolė.
• Django: Pilnai funkcionalus karkasas, teikiantis platų įrankių ir funkcijų rinkinį, įskaitant ORM, šablonų variklį ir administratoriaus sąsają. Jis puikiai tinka sudėtingoms programoms, reikalaujančioms tvirtos ir mastelį keičiančios architektūros.
• FastAPI: Modernus, didelio našumo karkasas, sukurtas remiantis ASGI, skirtas greitai ir efektyviai kurti API. Jis pasižymi asinchroninėmis operacijomis ir yra stiprus konkurentas mikropaslaugų ir didelio pralaidumo programoms.

Testavimo aplinkos paruošimas

Siekiant užtikrinti sąžiningą ir tikslų palyginimą, naudosime standartizuotą testavimo aplinką. Tai apima:

• Aparatinė įranga: Specializuotas serveris su pastoviomis specifikacijomis (pvz., CPU, RAM, saugykla). Tikslios specifikacijos bus nurodytos ir išliks nekintamos visų testų metu.
• Programinė įranga: Naujausios stabilios Python, Flask, Django ir FastAPI versijos. Naudosime nuoseklią Gunicorn ir Uvicorn versiją WSGI/ASGI serveriams.
• Duomenų bazė: PostgreSQL, populiari atvirojo kodo reliacinė duomenų bazė, sukonfigūruota optimaliam našumui.
• Apkrovos testavimo įrankis: Locust, Python pagrįstas apkrovos testavimo įrankis, naudojamas imituoti vienu metu veikiančius vartotojus ir matuoti programos našumą.
• Stebėjimo įrankiai: Prometheus ir Grafana, skirti stebėti serverio resursų naudojimą (CPU, atmintis, tinklas).
• Testavimo atvejai: Apibrėšime kelis testavimo atvejus, kurie atspindi įprastus žiniatinklio programų scenarijus:
• Sveikas, pasauli: Paprastas galinis taškas, kuris grąžina statinę eilutę. Tai patikrina pagrindines karkaso maršruto parinkimo ir užklausų tvarkymo pridėtines išlaidas.
• Duomenų bazės skaitymas: Galinis taškas, kuris nuskaito duomenis iš duomenų bazės. Tai patikrina karkaso ORM (arba duomenų bazės sąveikos sluoksnio) našumą.
• Duomenų bazės rašymas: Galinis taškas, kuris įrašo duomenis į duomenų bazę. Tai patikrina karkaso ORM (arba duomenų bazės sąveikos sluoksnio) našumą rašymo operacijų metu.
• JSON serializavimas: Galinis taškas, kuris serializuoja duomenis į JSON formatą. Tai patikrina karkaso serializavimo našumą.

Testavimo aplinkos konfigūracijos detalės

• CPU: Intel Xeon E3-1231 v3 @ 3.40GHz
• RAM: 16GB DDR3
• Saugykla: 256GB SSD
• Operacinė sistema: 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

Vienu metu vykdomų užklausų lygiai: Norėdami išsamiai įvertinti našumą, kiekvieną karkasą testuosime esant įvairiems vienu metu vykdomų užklausų lygiams, nuo 10 iki 500 vienu metu veikiančių vartotojų. Tai leis mums stebėti, kaip kiekvienas karkasas keičia mastelį didėjant apkrovai.

Karkasų įgyvendinimai

Kiekvienam karkasui sukursime paprastą programą, kuri įgyvendina aukščiau aprašytus testavimo atvejus.

Flask

Flask naudoja Werkzeug WSGI įrankių rinkinį. Duomenų bazės sąveikai naudosime SQLAlchemy, populiarų ORM. Štai supaprastintas pavyzdys:

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 naudoja savo integruotą ORM ir šablonų variklį. Štai supaprastintas pavyzdys:

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 yra sukurtas remiantis ASGI ir naudoja Pydantic duomenų patvirtinimui. Duomenų bazės sąveikai naudosime SQLAlchemy. Jis natūraliai palaiko asinchroninį užklausų tvarkymą.

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

Testavimo rezultatai

Šiose lentelėse apibendrinti kiekvieno testavimo atvejo rezultatai. Rezultatai pateikiami užklausų per sekundę (RPS) ir vidutinės delsos (milisekundėmis) terminais.

Sveikas, pasauli

Karkasas	Vienu metu vykdomos užklausos	Užklausos per sekundę (RPS)	Uždelsa (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

Duomenų bazės skaitymas

Karkasas	Vienu metu vykdomos užklausos	Užklausos per sekundę (RPS)	Uždelsa (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

Duomenų bazės rašymas

Karkasas	Vienu metu vykdomos užklausos	Užklausos per sekundę (RPS)	Uždelsa (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

JSON serializavimas

Karkasas	Vienu metu vykdomos užklausos	Užklausos per sekundę (RPS)	Uždelsa (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

Pastaba: Pakeiskite vietos rezervavimo simbolius (X, Y, A, B ir t.t.) faktiniais testavimo rezultatais, gautais vykdant testus. Šie rezultatai būtų užpildyti po testų paleidimo naudojant „Locust“ ir kitus stebėjimo įrankius.

Analizė ir interpretacija

Remiantis testavimo rezultatais (pakeiskite vietos rezervavimo simbolius savo faktiniais duomenimis), galime daryti šias išvadas:

• FastAPI paprastai pranoksta Flask ir Django pagal RPS ir delsą, ypač esant dideliam vienu metu vykdomų užklausų skaičiui. Taip yra dėl jo asinchroninio pobūdžio ir optimizuoto duomenų patvirtinimo naudojant Pydantic.
• Flask suteikia gerą pusiausvyrą tarp našumo ir lankstumo. Tai tinkamas pasirinkimas mažesniems projektams arba kai reikalinga smulkiagrūdė programos architektūros kontrolė.
• Django, nors ir yra pilnai funkcionalus karkasas, gali rodyti mažesnį našumą palyginti su FastAPI, ypač API intensyvioms programoms. Tačiau jis siūlo gausų funkcijų ir įrankių rinkinį, kuris gali supaprastinti sudėtingų projektų kūrimą.
• Duomenų bazių sąveikos gali tapti kliūtimi, nepriklausomai nuo karkaso. Duomenų bazės užklausų optimizavimas ir spartinimo mechanizmų (angl. caching) naudojimas gali žymiai pagerinti našumą.
• JSON serializavimo pridėtinės išlaidos gali paveikti našumą, ypač galiniams taškams, kurie grąžina didelius duomenų kiekius. Efektyvių serializavimo bibliotekų ir metodų naudojimas gali padėti tai sušvelninti.

Globalūs aspektai ir diegimas

Diegiant žiniatinklio programas visame pasaulyje, atsižvelkite į šiuos veiksnius:

• Geografinis pasiskirstymas: Naudokite turinio pristatymo tinklą (CDN), kad spartintumėte statinį turinį ir sumažintumėte delsą vartotojams skirtinguose regionuose.
• Duomenų bazės vieta: Pasirinkite duomenų bazės vietą, kuri yra geografiškai arti didžiosios dalies jūsų vartotojų.
• Laiko juostos: Teisingai tvarkykite laiko juostas, kad datos ir laikai būtų rodomi tiksliai vartotojams skirtinguose regionuose. Svarbios bibliotekos, tokios kaip pytz.
• Lokalizacija ir internacionalizacija: Įdiekite lokalizaciją ir internacionalizaciją (i18n/l10n), kad palaikytumėte kelias kalbas ir kultūras. Django turi integruotą palaikymą, o Flask turi plėtinius, tokius kaip Flask-Babel.
• Valiutų tvarkymas: Užtikrinkite, kad teisingai tvarkote skirtingas valiutas, įskaitant formatavimą ir konvertavimo kursus.
• Duomenų privatumo reglamentai: Laikykitės duomenų privatumo reglamentų, tokių kaip GDPR (Europa), CCPA (Kalifornija) ir kitų, priklausomai nuo jūsų tikslinės auditorijos.
• Mastelio keitimas: Suprojektuokite savo programą taip, kad ją būtų galima keisti horizontaliai, siekiant atlaikyti didėjantį srautą iš skirtingų regionų. Konteinerizavimas (Docker) ir orkestravimas (Kubernetes) yra įprastos technikos.
• Stebėjimas ir registravimas: Įdiekite išsamų stebėjimą ir registravimą, kad galėtumėte sekti programos našumą ir nustatyti problemas skirtinguose regionuose.

Pavyzdžiui, įmonė, įsikūrusi Vokietijoje ir aptarnaujanti klientus tiek Europoje, tiek Šiaurės Amerikoje, turėtų apsvarstyti galimybę naudoti CDN su serveriais abiejuose regionuose, talpinti savo duomenų bazę geografiškai centre, atsižvelgiant į vartotojų bazę (pvz., Airijoje arba JAV Rytų pakrantėje), ir įdiegti i18n/l10n, kad palaikytų anglų ir vokiečių kalbas. Jie taip pat turėtų užtikrinti, kad jų programa atitiktų GDPR ir visus taikomus JAV valstijų privatumo įstatymus.

Išvados

Tinklo karkaso pasirinkimas priklauso nuo konkrečių jūsų projekto reikalavimų. FastAPI siūlo puikų našumą API intensyvioms programoms, o Flask suteikia lankstumą ir paprastumą. Django yra tvirtas, pilnai funkcionalus karkasas, tinkamas sudėtingiems projektams. Kruopščiai įvertinkite savo projekto reikalavimus ir atsižvelkite į šiame straipsnyje pateiktus testavimo rezultatus, kad priimtumėte pagrįstą sprendimą.

Praktinės įžvalgos

• Vykdykite savo palyginamąsias analizes: Pritaikykite šiuos testus savo konkretiems naudojimo atvejams ir infrastruktūrai.
• Apsvarstykite asinchronines užduotis: Jei turite ilgai trunkančių užduočių, naudokite asinchroninių užduočių eiles, pavyzdžiui, Celery.
• Optimizuokite duomenų bazės užklausas: Naudokite indeksavimą, spartinimą (angl. caching) ir efektyvų užklausų dizainą.
• Profiluokite savo programą: Naudokite profiliavimo įrankius, kad nustatytumėte kliūtis.
• Stebėkite našumą: Reguliariai stebėkite savo programos našumą gamybinėje aplinkoje.

Papildoma literatūra

• Flask dokumentacija
• Django dokumentacija
• FastAPI dokumentacija
• Uvicorn dokumentacija
• Gunicorn dokumentacija
• Locust dokumentacija