Tīmekļa ietvaru veiktspēja: Flask, Django un FastAPI salīdzinošais tests

Pareiza tīmekļa ietvara izvēle ir ļoti svarīga, lai veidotu efektīvas un mērogojamas tīmekļa lietojumprogrammas. Python piedāvā vairākas lieliskas iespējas, katrai no kurām ir savas stiprās un vājās puses. Šajā rakstā sniegts visaptverošs salīdzinošais tests, kurā salīdzināti trīs populāri ietvari: Flask, Django un FastAPI. Mēs analizēsim to veiktspējas īpašības, resursu izmantošanu un piemērotību dažādiem lietojumprogrammu veidiem, ņemot vērā globālās izstrādes prakses un izvietošanas vides.

Ievads

Tīmekļa ietvari nodrošina strukturētu vidi tīmekļa lietojumprogrammu izveidei, apstrādājot tādus uzdevumus kā maršrutēšana, pieprasījumu apstrāde un datu bāzes mijiedarbība. Ietvara izvēle būtiski ietekmē lietojumprogrammas veiktspēju, īpaši pie lielas slodzes. Šī salīdzinošā testa mērķis ir sniegt uz datiem balstītu ieskatu, lai palīdzētu izstrādātājiem pieņemt pamatotus lēmumus.

• Flask: Mikroietvars, kas piedāvā vienkāršību un elastību. Tā ir laba izvēle maziem un vidējiem projektiem, kur nepieciešama precīza kontrole.
• Django: Pilnfunkcionāls ietvars, kas nodrošina visaptverošu rīku un funkciju kopumu, tostarp ORM, veidņu dzinēju un administratora saskarni. Tas ir labi piemērots sarežģītām lietojumprogrammām, kurām nepieciešama stabila un mērogojama arhitektūra.
• FastAPI: Moderns, augstas veiktspējas ietvars, kas balstīts uz ASGI un paredzēts ātrdarbīgu un efektīvu API izveidei. Tas izceļas ar asinhronām operācijām un ir spēcīgs konkurents mikropakalpojumiem un augstas caurlaidības lietojumprogrammām.

Testa uzstādījumi

Lai nodrošinātu godīgu un precīzu salīdzinājumu, mēs izmantosim standartizētu testa uzstādījumu. Tas ietver:

• Aparatūra: Speciāls serveris ar nemainīgām specifikācijām (piem., CPU, RAM, krātuve). Precīzas specifikācijas tiks norādītas un saglabātas nemainīgas visos testos.
• Programmatūra: Jaunākās stabilās Python, Flask, Django un FastAPI versijas. Mēs izmantosim vienādas Gunicorn un Uvicorn versijas WSGI/ASGI serveriem.
• Datu bāze: PostgreSQL, populāra atvērtā koda relāciju datu bāze, kas konfigurēta optimālai veiktspējai.
• Slodzes testēšanas rīks: Locust, Python bāzēts slodzes testēšanas rīks, ko izmanto, lai simulētu vienlaicīgus lietotājus un mērītu lietojumprogrammas veiktspēju.
• Monitoringa rīki: Prometheus un Grafana, lai uzraudzītu servera resursu izmantošanu (CPU, atmiņa, tīkls).
• Testa gadījumi: Mēs definēsim vairākus testa gadījumus, kas atspoguļo izplatītus tīmekļa lietojumprogrammu scenārijus:
• Hello World: Vienkāršs galapunkts, kas atgriež statisku virkni. Tas pārbauda ietvara pamata maršrutēšanas un pieprasījumu apstrādes pieskaitāmās izmaksas.
• Datu bāzes lasīšana: Galapunkts, kas izgūst datus no datu bāzes. Tas pārbauda ietvara ORM (vai datu bāzes mijiedarbības slāņa) veiktspēju.
• Datu bāzes rakstīšana: Galapunkts, kas raksta datus datu bāzē. Tas pārbauda ietvara ORM (vai datu bāzes mijiedarbības slāņa) veiktspēju rakstīšanas operāciju laikā.
• JSON serializācija: Galapunkts, kas serializē datus JSON formātā. Tas pārbauda ietvara serializācijas veiktspēju.

Salīdzinošās vides konfigurācijas detaļas

• CPU: Intel Xeon E3-1231 v3 @ 3.40GHz
• RAM: 16GB DDR3
• Krātuve: 256GB SSD
• Operētājsistēma: 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

Vienlaicīguma līmeņi: Lai rūpīgi novērtētu veiktspēju, mēs pārbaudīsim katru ietvaru dažādos vienlaicīguma līmeņos, sākot no 10 līdz 500 vienlaicīgiem lietotājiem. Tas ļaus mums novērot, kā katrs ietvars mērogojas, pieaugot slodzei.

Ietvaru implementācijas

Katram ietvaram mēs izveidosim vienkāršu lietojumprogrammu, kas implementē iepriekš aprakstītos testa gadījumus.

Flask

Flask izmanto Werkzeug WSGI rīkkopu. Datu bāzes mijiedarbībai mēs izmantosim SQLAlchemy, populāru ORM. Šeit ir vienkāršots piemērs:

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 izmanto savu iebūvēto ORM un veidņu dzinēju. Šeit ir vienkāršots piemērs:

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 ir veidots uz ASGI un izmanto Pydantic datu validācijai. Datu bāzes mijiedarbībai mēs izmantosim SQLAlchemy. Tas dabiski atbalsta asinhronu pieprasījumu apstrādi.

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

Testa rezultāti

Nākamajās tabulās apkopoti katra testa gadījuma rezultāti. Rezultāti tiek parādīti kā pieprasījumi sekundē (RPS) un vidējais latentums (milisekundēs).

Hello World

Ietvars	Vienlaicīgums	RPS	Latentums (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

Datu bāzes lasīšana

Ietvars	Vienlaicīgums	RPS	Latentums (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

Datu bāzes rakstīšana

Ietvars	Vienlaicīgums	RPS	Latentums (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 serializācija

Ietvars	Vienlaicīgums	RPS	Latentums (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

Piezīme: Aizstājiet vietturu vērtības (X, Y, A, B utt.) ar faktiskajiem testa rezultātiem, kas iegūti, veicot testus. Šie rezultāti tiktu aizpildīti pēc testu veikšanas, izmantojot locust un citus monitoringa rīkus.

Analīze un interpretācija

Pamatojoties uz salīdzinošā testa rezultātiem (aizstājiet vietturus ar saviem faktiskajiem datiem), mēs varam izdarīt šādus secinājumus:

• FastAPI parasti pārspēj Flask un Django attiecībā uz RPS un latentumu, īpaši pie augsta vienlaicīguma. Tas ir saistīts ar tā asinhrono dabu un optimizēto datu validāciju, izmantojot Pydantic.
• Flask nodrošina labu līdzsvaru starp veiktspēju un elastību. Tā ir piemērota izvēle mazākiem projektiem vai tad, kad nepieciešama precīza kontrole pār lietojumprogrammas arhitektūru.
• Django, lai gan tas ir pilnfunkcionāls ietvars, var uzrādīt zemāku veiktspēju salīdzinājumā ar FastAPI, īpaši API ietilpīgām lietojumprogrammām. Tomēr tas piedāvā bagātīgu funkciju un rīku kopumu, kas var vienkāršot izstrādi sarežģītiem projektiem.
• Datu bāzes mijiedarbība var būt vājā vieta, neatkarīgi no ietvara. Datu bāzes vaicājumu optimizēšana un kešošanas mehānismu izmantošana var ievērojami uzlabot veiktspēju.
• JSON serializācijas pieskaitāmās izmaksas var ietekmēt veiktspēju, īpaši galapunktiem, kas atgriež lielu datu apjomu. Efektīvu serializācijas bibliotēku un metožu izmantošana var palīdzēt to mazināt.

Globāli apsvērumi un izvietošana

Izvietojot tīmekļa lietojumprogrammas globāli, ņemiet vērā šādus faktorus:

• Ģeogrāfiskais sadalījums: Izmantojiet satura piegādes tīklu (CDN), lai kešotu statiskos resursus un samazinātu latentumu lietotājiem dažādos reģionos.
• Datu bāzes atrašanās vieta: Izvēlieties datu bāzes atrašanās vietu, kas ir ģeogrāfiski tuvu lielākajai daļai jūsu lietotāju.
• Laika joslas: Pareizi apstrādājiet laika joslas, lai nodrošinātu, ka datumi un laiki tiek attēloti precīzi lietotājiem dažādos reģionos. Būtiskas ir tādas bibliotēkas kā pytz.
• Lokalizācija un internacionalizācija: Implementējiet lokalizāciju un internacionalizāciju (i18n/l10n), lai atbalstītu vairākas valodas un kultūras. Django ir iebūvēts atbalsts, un Flask ir paplašinājumi, piemēram, Flask-Babel.
• Valūtas apstrāde: Nodrošiniet, ka pareizi apstrādājat dažādas valūtas, ieskaitot formatēšanu un konversijas kursus.
• Datu privātuma regulas: Ievērojiet datu privātuma regulas, piemēram, GDPR (Eiropa), CCPA (Kalifornija) un citas, atkarībā no jūsu mērķauditorijas.
• Mērogojamība: Projektējiet savu lietojumprogrammu tā, lai tā varētu mērogoties horizontāli, lai apstrādātu pieaugošo datplūsmu no dažādiem reģioniem. Konteinerizācija (Docker) un orķestrēšana (Kubernetes) ir izplatītas metodes.
• Monitorings un žurnālēšana: Implementējiet visaptverošu monitoringu un žurnālēšanu, lai sekotu līdzi lietojumprogrammas veiktspējai un identificētu problēmas dažādos reģionos.

Piemēram, uzņēmumam, kas atrodas Vācijā un apkalpo klientus gan Eiropā, gan Ziemeļamerikā, būtu jāapsver iespēja izmantot CDN ar malu atrašanās vietām abos reģionos, mitināt savu datu bāzi reģionā, kas ir ģeogrāfiski centrāls tā lietotāju bāzei (piemēram, Īrijā vai ASV austrumu piekrastē), un ieviest i18n/l10n, lai atbalstītu angļu un vācu valodu. Viņiem arī jānodrošina, ka viņu lietojumprogramma atbilst GDPR un visiem piemērojamiem ASV štatu privātuma likumiem.

Noslēgums

Tīmekļa ietvara izvēle ir atkarīga no jūsu projekta specifiskajām prasībām. FastAPI piedāvā izcilu veiktspēju API ietilpīgām lietojumprogrammām, savukārt Flask nodrošina elastību un vienkāršību. Django ir stabils pilnfunkcionāls ietvars, kas piemērots sarežģītiem projektiem. Rūpīgi izvērtējiet sava projekta prasības un apsveriet šajā rakstā sniegtos testa rezultātus, lai pieņemtu pamatotu lēmumu.

Praktiski ieteikumi

• Veiciet savus salīdzinošos testus: Pielāgojiet šos testus saviem specifiskajiem lietošanas gadījumiem un infrastruktūrai.
• Apsveriet asinhronus uzdevumus: Ja jums ir ilgstoši uzdevumi, izmantojiet asinhronās uzdevumu rindas, piemēram, Celery.
• Optimizējiet datu bāzes vaicājumus: Izmantojiet indeksēšanu, kešošanu un efektīvu vaicājumu dizainu.
• Profilējiet savu lietojumprogrammu: Izmantojiet profilēšanas rīkus, lai identificētu vājās vietas.
• Pārraugiet veiktspēju: Regulāri pārraugiet savas lietojumprogrammas veiktspēju produkcijā.

Papildu lasāmviela

• Flask dokumentācija
• Django dokumentācija
• FastAPI dokumentācija
• Uvicorn dokumentācija
• Gunicorn dokumentācija
• Locust dokumentācija